#include <iostream>
#include <algorithm>
#include <cstring>
#include <queue>
#include <unordered_map>

using namespace std;

const int N = 510, M = 1e5+10, INF = 0x3f3f3f3f;

typedef pair<string,string> PSS;
typedef long long LL;
struct Edge{
    int v,c,ne;
} e[M];

int h[N],idx = 1,cur[N],d[N];
int n,m,k,g[400][400];
int S,T;
unordered_map<string,int> id;
vector<string> dv;
vector<string> dz;

void add(int a,int b,int c){
    e[++idx] = {b,c,h[a]};
    h[a] = idx;
}

bool bfs(){
    memset(d,0,sizeof d);
    d[S] = 1;
    queue<int> q;q.push(S);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        for(int i = h[u]; i != -1; i = e[i].ne){
            int v = e[i].v;
            if(!d[v] && e[i].c){
                d[v] = d[u] + 1;
                q.push(v);
                if(v == T)return true;
            }
        }
    }
    return false;
}

LL dfs(int u,LL mf){
    if(u == T)return mf;
    LL sum = 0;
    for(int i = cur[u]; i != -1; i = e[i].ne){
        cur[u] = i;
        int v = e[i].v;
        if(d[v] == d[u] + 1 && e[i].c){
            LL f = dfs(v,min(mf,(LL)e[i].c));
            e[i].c -= f;
            e[i^1].c += f;
            sum += f;
            mf -= f;
            if(!mf)break;
        }
    }
    if(sum == 0)d[u] = 0;
    return sum;
}

LL dinic(){
    LL flow = 0;
    while(bfs()){
        memcpy(cur,h,sizeof h);
        flow += dfs(S,INF);
    }
    return flow;
}
void Floyd(int n){
    for(int k = 1; k <= n; ++k){
        for(int i = 1; i <= n; ++i){
            for(int j = 1; j <= n; ++j){
                if(i == j)g[i][j] = 1;
                g[i][j] = (g[i][j] || (g[i][k] && g[k][j]));
            }
        }
    }
}
int main()
{
    //freopen("out.txt","w",stdout);
    int cases;
    cin >> cases;
    while(cases --) {
        dz.clear();
        dv.clear();
        id.clear();
        idx = 1;
        memset(h,-1,sizeof h);
        memset(g,0,sizeof g);
        int cnt = 0;
        cin >> n;
        while(n -- ) {
            string z;
            cin >> z;
            dz.push_back(z);
            if(!id.count(z))id[z] = ++cnt;
        }
        cin >> m;
        for(int i = 0; i < m ;++i){
            string nm,z;
            cin >> nm >> z;
            dv.push_back(z);
            if(!id.count(z))id[z] = ++cnt;
        }
        cin >>k;
        while(k -- ) {
            string z,t;
            cin >> z >> t;
            if(!id.count(z))id[z] = ++cnt;
            if(!id.count(t))id[t] = ++cnt;
            g[id[z]][id[t]] = 1;
        }

        Floyd(cnt);
        S = 0,T = cnt + 1;
        for(int i = 0; i < dz.size(); ++i)add(id[dz[i]],T,1),add(T,id[dz[i]],0);
        for(int i = 1; i <= dv.size(); ++i){
            string t = dv[i - 1];
            int a = id[t];
            add(S,T + i,1),add(T + i,S,0);
            for(int j = 1; j <= cnt; ++j){
                if(g[a][j])add(T + i,j,INF),add(j,T + i,0);
            }
        }
        LL t = dinic();
        printf("%lld\n",m - t);
        if(cases)puts("");
    }

    return 0;
}