#include<bits/stdc++.h>
using namespace std;
const int INF = 1 << 30, N = 40010;
int n1, n2, n3, m1, m2, s, t;
struct Edge {
    int from, to, flow;
    Edge(int u, int v, int f) : from(u), to(v), flow(f) {}
};
vector<Edge> edges;
vector<int> G[N];
void addEdge(int from, int to, int flow) {
    edges.push_back((Edge){from, to, flow});
    edges.push_back((Edge){to, from, 0});
    G[from].push_back(edges.size() - 2);
    G[ to ].push_back(edges.size() - 1);
}

int d[N];
queue<int>q;
bool bfs() {
    memset(d, 0, sizeof(d));
    while (!q.empty()) q.pop();
    q.push(s), d[s] = 1;
    while (!q.empty()) {
        int x = q.front(); q.pop();
        if (x == t) return true;
        for (int i = 0; i < G[x].size(); ++i) {
            Edge &e = edges[G[x][i]];
            int to = e.to;
            if (!d[to] && e.flow)
                q.push(to), d[to] = d[x] + 1;
        }
    }
    return false;
}
int Dinic (int x, int flow) {
    if (x == t) return flow;
    int rest = flow;
    for (int i = 0; i < G[x].size(); ++i) {
        Edge &e = edges[G[x][i]], &fe = edges[G[x][i]^1];
        int to = e.to;
        if (e.flow && d[to] == d[x] + 1) {
            int k = Dinic(to, min(rest, e.flow));
            //if (!k) d[to] = 0;
            e.flow -= k, fe.flow += k;
            rest -= k;
        }
    }
    //if (rest == flow) d[x] = 0;
    return flow - rest;
}
int main()
{
    scanf("%d%d%d", &n1, &n2, &n3);
    scanf("%d", &m1);
    for (int i = 1; i <= n1; ++i)
        addEdge(n2 + i, n1 + n2 + i, 1);
    for (int i = 1; i <= m1; ++i) {
        int u, v;
        scanf("%d%d",&u, &v);
        addEdge(v, n2 + u, 1);
    }
    scanf("%d", &m2);
    for (int i = 1; i <= m2; ++i) {
        int u, v;
        scanf("%d%d", &u, &v);
        addEdge(n1 + n2 + u, 2 * n1 + n2 + v, 1);
    }
    s = 0, t = 2 * n1 + n2 + n3 + 1;

    for (int i = 1; i <= n2; ++i)
        addEdge(s, i, 1);
    for (int i = 1; i <= n3; ++i)
        addEdge(2 * n1 + n2 + i, t, 1);

    //solve
    int maxflow = 0;
    int flow;
    while (bfs())
        while (flow = Dinic(s, INF)) maxflow += flow;

    //output
	printf("%d\n", maxflow);
	return 0;
}

int Dinic (int x, int flow) {
    if (x == t) return flow;
    int rest = flow;
    for (int i = 0; i < G[x].size(); ++i) {
        Edge &e = edges[G[x][i]], &fe = edges[G[x][i]^1];
        int to = e.to;
        if (e.flow && d[to] == d[x] + 1) {
            int k = Dinic(to, min(rest, e.flow));
            //if (!k) d[to] = 0;
            e.flow -= k, fe.flow += k;
            rest -= k;
            if (rest == 0) break;
        }
    }
    //if (rest == flow) d[x] = 0;
    return flow - rest;
}

int Dinic (int x, int flow) {
    if (x == t) return flow;
    int rest = flow;
    for (int i = 0; i < G[x].size(); ++i) {
        Edge &e = edges[G[x][i]], &fe = edges[G[x][i]^1];
        int to = e.to;
        if (e.flow && d[to] == d[x] + 1) {
            int k = Dinic(to, min(rest, e.flow));
            if (!k) d[to] = 0;
            e.flow -= k, fe.flow += k;
            rest -= k;
            if (rest == 0) break;
        }
    }
    //if (rest == flow) d[x] = 0;
    return flow - rest;
}

int Dinic (int x, int flow) {
    if (x == t) return flow;
    int rest = flow;
    for (int i = 0; i < G[x].size(); ++i) {
        Edge &e = edges[G[x][i]], &fe = edges[G[x][i]^1];
        int to = e.to;
        if (e.flow && d[to] == d[x] + 1) {
            int k = Dinic(to, min(rest, e.flow));
            //if (!k) d[to] = 0;
            e.flow -= k, fe.flow += k;
            rest -= k;
            if (rest == 0) break;
        }
    }
    if (rest == flow) d[x] = 0;
    return flow - rest;
}

//Author:XuHt
#include <cmath>
#include <queue>
#include <cstdio>
#include <vector>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 362886;
int fa[N], f[N];
bool v[N];
// int dx[4] = {-1,0,1,0};
// int dy[4] = {0,-1,0,1};
int dx[4] = {-1,0,1,0};
int dy[4] = {0,1,0,-1};
int jc[10] = {1,1,2,6,24,120,720,5040,40320,362880};
struct P {
	int i, x, y;
	string s;
	bool operator < (const P a) const {
		return x + y > a.x + a.y;
	}
};
priority_queue<P> q;

int cantor(string st) {
	int len = st.size();
	for (int i = 0; i < len; i++)
		if (st[i] == 'x') {
			st[i] = '0';
			break;
		}
	int ans = 1;
	for (int i = 0; i < len; i++) {
		int num = 0;
		for (int j = 0; j < i; j++) if (st[j] < st[i]) ++num;
		ans += (st[i] - '0' - num) * jc[len-i-1];
	}
	return ans;
}

int S(string s) {
	int ans = 0;
	for (unsigned int i = 0; i < s.size(); i++) {
		int r = i / 3, c = i % 3;
		if (s[i] == 'x') ans += abs(r - 2) + abs(c - 2);
		else {
			int k = s[i] - '1';
			ans += abs(r - k / 3) + abs(c - k % 3);
		}
	}
	return ans;
}

bool bfs(string st) {
	string ed = "12345678x";
	memset(v, 0, sizeof(v));
	memset(fa, -1, sizeof(fa));
	memset(f, -1, sizeof(f));
	int k;
	for (int i = 0; i < 10; i++)
		if (st[i] == 'x') {
			k = i;
			break;
		}
	P p;
	p.i = k;
	p.x = 1;
	p.y = S(st);
	p.s = st;
	q.push(p);
	v[cantor(st)] = 1;
	while (q.size()) {
		p = q.top();
		if (p.s == ed) return 1;
		q.pop();
		int r = p.i / 3, c = p.i % 3;
		for (int i = 0; i < 4; i++) {
			int nx = r + dx[i], ny = c + dy[i];
			if (nx < 0 || nx > 2 || ny < 0 || ny > 2) continue;
			string s = p.s;
			swap(s[p.i], s[nx*3+ny]);
			if (v[cantor(s)]) continue;
			v[cantor(s)] = 1;
			fa[cantor(s)] = cantor(p.s);
			f[cantor(s)] = i;
			P np;
			np.i = nx * 3 + ny;
			np.x = p.x + 1;
			np.y = S(s);
			np.s = s;
			q.push(np);
		}
	}
	return 0;
}

int main() {
	string st = "";
	for (int i = 1; i < 10; i++) {
		char s[2];
		cin >> s;
		st += s[0];
	}
	int cnt = 0;
	for (unsigned i = 0; i < st.size(); i++)
		if (st[i] != 'x')
			for (unsigned int j = 0; j < i; j++)
				if (st[j] != 'x' && st[j] > st[i]) ++cnt;
	if (cnt & 1) {
		cout << "unsolvable" << endl;
		return 0;
	}
	vector<int> ans;
	if (bfs(st)) {
		int k = cantor("12345678x");
		while (k != -1) {
			ans.push_back(f[k]);
			k = fa[k];
		}
		for (unsigned int i = ans.size() - 1; i < ans.size(); i--)
// 			if (ans[i] == 0) putchar('u');
// 			else if (ans[i] == 1) putchar('l');
// 			else if (ans[i] == 2) putchar('d');
// 			else if (ans[i] == 3) putchar('r');
			if (ans[i] == 0) putchar('u');
			else if (ans[i] == 1) putchar('r');
			else if (ans[i] == 2) putchar('d');
			else if (ans[i] == 3) putchar('l');
	} else puts("unsolvable");
	return 0;
}

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<set>
#include<cmath>
#include<string>
using namespace std;
string s1, s2;
int n1, n2;
long long f[105][32];

void solve() {
	memset(f, 0, sizeof(f));
	for (int i = 0; i < s1.size(); i++) {
		int pos = i;
		f[i][0] = 0;
		for (int j = 0; j < s2.size(); j++) {
			int cnt = 0;
			while (s1[pos] != s2[j]) {
				pos = (pos + 1) % s1.size();
				if (++cnt >= s1.size()) { 
					cout << 0 << endl; 
					return;
				}
			}
			pos = (pos + 1) % s1.size();
			f[i][0] += cnt + 1;
		}
	}
	for (int j = 1; j <= 30; j++)
		for (int i = 0; i < s1.size(); i++)
			f[i][j] = f[i][j - 1] + f[(i + f[i][j - 1]) % s1.size()][j - 1];
	long long m = 0;
	for (int st = 0; st < s1.size(); st++) { // HERE
		long long x = st, ans = 0;
		for (int k = 30; k >= 0; k--) {
			if (x + f[x%s1.size()][k] <= s1.size()*n1) {
				x += f[x%s1.size()][k];
				ans += 1 << k;
			}
		}
		m = max(m, ans);
	}
	cout << m / n2 << endl;
}

int main()  {
	while(cin >> s2 >> n2 >> s1 >> n1) solve();
}

#include<bits/stdc++.h>
using namespace std;
const int maxn = 13;

int n,m;
long long f[maxn][1<<maxn];

int a[1<<maxn], ct;

void solve()
{
    
    ct = 0;
    for(int i=0; i<(1<<m); ++i)
    {
        int cnt=0, is_odd=0;
        for(int j=0;j<m;++j)
          if((i>>j)&1) cnt^=1;
          else is_odd|=cnt, cnt=0;
        is_odd|=cnt;
        if(is_odd==0) a[++ct]=i;
    }
    
    memset(f, 0, sizeof f);
    for(int i=0; i<(1<<m); ++i)
    {
        int cnt=0, is_odd=0;
        for(int j=0;j<m;++j)
          if((i>>j)&1) is_odd|=cnt, cnt=0;
          else cnt^=1;
        is_odd|=cnt;
        if(is_odd==0) f[1][i]=1;
    }
    for(int i=2; i<=n; ++i)
        for(int j=0; j<(1<<m); ++j)
            for(int k=1; k<=ct; ++k) {
                if(j & a[k]) continue;
                int nowtmp = j | a[k];
                nowtmp = nowtmp ^ ((1<<m)-1);
                f[i][nowtmp] += f[i-1][j];
            }
    cout << f[n][0] << '\n';
}

int main()
{
    
    while(scanf("%d%d", &n, &m) != EOF && n) solve();
    return 0;
    
}

void insert(int i, int k, int p, int q) {
	if (k < 0) {
		latest[q] = i;
		return;
	}
	int c = s[i] >> k & 1;
	if (p) trie[q][c ^ 1] = trie[p][c ^ 1];
	trie[q][c] = ++tot;
	insert(i, k - 1, trie[p][c], trie[q][c]);
        // 这部分改成latest[q] = i，也能AC
	latest[q] = max(latest[trie[q][0]], latest[trie[q][1]]);
}

// Author:XuHt
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
using namespace std;
const int N = 100006, M = 1000006;
int n, m, tot = 0, Price[N];
int Head[N], Side[M], Next[M], ans[N];
int fHead[N], fSide[M], fNext[M], fans[N];
bool v[N], fv[N];
priority_queue<pair<int, int> > q;
priority_queue<pair<int, int> > fq;

int main() {
    cin >> n >> m;
    for (int i = 1; i <= n; i++) scanf("%d", &Price[i]);
    for (int i = 1; i <= m; i++) {
        int x, y, z;
        scanf("%d %d %d", &x, &y, &z);
        Side[++tot] = y;
        Next[tot] = Head[x];
        Head[x] = tot;
        fSide[tot] = x;
        fNext[tot] = fHead[y];
        fHead[y] = tot;
        if (z == 2) {
            Side[++tot] = x;
            Next[tot] = Head[y];
            Head[y] = tot;
            fSide[tot] = y;
            fNext[tot] = fHead[x];
            fHead[x] = tot;
        }
    }
    memset(ans, 0x3f, sizeof(ans));
    memset(fans, 0xcf, sizeof(fans));
    ans[1] = Price[1];
    fans[n] = Price[n];
    q.push(make_pair(-ans[1], 1));
    fq.push(make_pair(fans[n], n));
    while (q.size()) {
        int x = q.top().second;
        q.pop();
        if (v[x]) continue;
        v[x] = 1;
        for (int i = Head[x]; i; i = Next[i]) {
            int y = Side[i];
            if (ans[y] > ans[x]) {
                ans[y] = ans[x];
                ans[y] = min(ans[y], Price[y]);
                q.push(make_pair(-ans[y], y));
            }
        }
    }
    for (int i = 1; i <= n; ++i) cout << ans[i] << ' '; // 就是这里
    cout << endl;
    while (fq.size()) {
        int x = fq.top().second;
        fq.pop();
        if (fv[x]) continue;
        fv[x] = 1;
        for (int i = fHead[x]; i; i = fNext[i]) {
            int y = fSide[i];
            if (fans[y] < fans[x]) {
                fans[y] = fans[x];
                fans[y] = max(fans[y], Price[y]);
                fq.push(make_pair(fans[y], y));
            }
        }
    }
    int Ans = 0;
    for (int i = 1; i <= n; i++) Ans = max(Ans, fans[i] - ans[i]);
    cout << Ans << endl;
    return 0;
}

void dp(int x) {
	f[x][0] = 0;
	for (int i = 0; i < son[x].size(); i++) {
		int y = son[x][i];
		dp(y);
		for (int t = m; t >= 0; t--) 
			for (int j = 0; j <= t; j++)
                              f[x][t] = max(f[x][t], f[x][t-j] + f[y][j]);
			/* 或者
			for (int j = t; j >= 0; j--) // 经过实测，j 上界应为 m。树形结构的特殊性，y dp 过程已经结束，而 x 第二维度浅层次还未开始
				if (t + j <= m)
					f[x][t+j] = max(f[x][t+j], f[x][t] + f[y][j]);
                        */
	}
	if (x != 0)
		for(int t = m; t > 0; t--)
			f[x][t] = f[x][t-1] + s[x];
}

// tarjan算法求无向图的割点、点双连通分量并缩点

		printf("e-DCC #%d:", i);

		printf("v-DCC #%d:", i);

for(int i = 1; i < n; i++) {

for(int i = 1; i <= n; i++) {