#include <cstdio>

 #include <algorithm>

 #include <iostream>

 #include <cstring>

 #include <string>

 #include <cmath>

 #include <queue>

 #include <vector>

 #include <map>

 #include <set>

 using namespace std;

 #define INF 0x3f3f3f3f

 #define N 110

 typedef long long LL;

 struct Edge {

     int v, cap, nxt;

     Edge () {}

     Edge (int v, int cap, int nxt) : v(v), cap(cap), nxt(nxt) {}

 }edge[N*N*];

 int tot, cur[N], dis[N], pre[N], head[N], gap[N], S, T;

 void Add(int u, int v, int cap) {

     edge[tot] = Edge(v, cap, head[u]); head[u] = tot++;

     edge[tot] = Edge(u, , head[v]); head[v] = tot++;

 }

 void BFS() {

     queue<int> que;

     while(!que.empty()) que.pop();

     memset(dis, -, sizeof(dis));

     memset(gap, , sizeof(gap));

     dis[T] = ; gap[]++; que.push(T);

     while(!que.empty()) {

         int u = que.front(); que.pop();

         for(int i = head[u]; ~i; i = edge[i].nxt) {

             int v = edge[i].v;

             if(dis[v] == -) continue;

             dis[v] = dis[u] + ;

             gap[dis[v]]++;

             que.push(v);

         }

     }

 }

 int ISAP(int n) {

     memcpy(cur, head, sizeof(cur));

     BFS();

     int u = pre[S] = S, ans = , i;

     while(dis[S] < n) {

         if(u == T) {

             int flow = INF, index;

             for(int i = S; i != T; i = edge[cur[i]].v) {

                 Edge& e = edge[cur[i]];

                 if(e.cap < flow) {

                     flow = e.cap; index = i;

                 }

             }

             for(int i = S; i != T; i = edge[cur[i]].v) {

                 edge[cur[i]].cap -= flow;

                 edge[cur[i]^].cap += flow;

             }

             ans += flow; u = index;

         }

         for(i = cur[u]; ~i; i = edge[i].nxt)

             if(dis[edge[i].v] == dis[u] -  && edge[i].cap > )

                 break;

         if(~i) {

             cur[u] = i;

             pre[edge[i].v] = u;

             u = edge[i].v;

         } else {

             int md = n;

             if(--gap[dis[u]] == ) break;

             for(int i = head[u]; ~i; i = edge[i].nxt) {

                 if(md > dis[edge[i].v] && edge[i].cap > ) {

                     md = dis[edge[i].v]; cur[u] = i;

                 }

             }

             ++gap[dis[u] = md + ];

             u = pre[u];

         }

     }

     return ans;

 }

 int main() {

     int n, nc, np, m;

     while(~scanf("%d%d%d%d", &n, &np, &nc, &m)) {

         tot = ; memset(head, -, sizeof(head));

         S = n, T = n + ;

         int a, b, c;

         for(int i = ; i <= m; i++) {

             scanf(" (%d,%d)%d", &a, &b, &c);

             Add(a, b, c);

         }

         for(int i = ; i <= np; i++) {

             scanf(" (%d)%d", &a, &b);

             Add(S, a, b);

         }

         for(int i = ; i <= nc; i++) {

             scanf(" (%d)%d", &a, &b);

             Add(a, T, b);

         }

         printf("%d\n", ISAP(T+));

     }

     return ;

 }