#include <cstring>
#include <cmath>
#include <cstdio>
#include <climits>
#include <ctime>
#include <cassert>
#include <cctype>
#include <iostream>
#include <algorithm>
#include <numeric>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <vector>
#include <bitset>
#include <utility>

using namespace std;
#define all(x) (x).begin(), (x).end()
#define bit(x) (1 << (x))
#define cnt1(x) (__builtin_popcount(x))
#define LB lower_bound
#define LET(it,v) __typeof(v) it(v)
#define mset0(x) memset((x), 0, sizeof((x)))
#define mset1(x) memset((x), -1, sizeof((x)))
#define pb push_back
#define PQ priority_queue
#define REP(it,v) for(LET(it,v.begin());it!=v.end();it++)
#define sqr(x) ((x)*(x))
#define sz(x) ((int)(x.size()))
#define UB upper_bound
#define X first
#define Y second
#pragma comment(linker, "/STACK:256000000")

typedef long long LL;
typedef double DB;
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
typedef vector<int> vi;
typedef vector<pii> vpii;

template <class T> inline void chkmin(T &a, T b) {
    if (b < a) a = b;
}
template <class T> inline void chkmax(T &a, T b) {
    if (a < b) a = b;
}

const int MX = 2005;

map<string, int> T;
int tcnt;
vector <string> TV;

map<string, int> V;
int vcnt;

int THash(string s) {
    if (T.count(s)) return T[s];
    TV.pb(s);
    return T[s] = ++tcnt;
}
int VHash(string s) {
    if (V.count(s)) return V[s];
    return V[s] = ++vcnt;
}

int n;
int a[MX], b[MX];
vi con[MX];
char can[MX][MX];
char s[500005];

int calc(int st, int en) {
    if (st > en) return -1;
    
    int cnt = 0;
    int i;
    
    for (i = st; i <= en; i++) {
        if (s[i] == '(') cnt++;
        else if (s[i] == ')') cnt--;
        if (cnt) continue;
        
        if (s[i] == '*') {
            int y = calc(st, i - 1);
            int x = calc(i + 1, en);
            if (x == -1 || y == -1) return -1;
            if (!can[x][y]) return -1;
            return y;
        }
    }
    
    if (cnt) return -1;
    for (i = st; i <= en; i++)
        if (s[i] == '(') break;
    
    if (i != en + 1) {
        if (s[en] != ')') return -1;
        s[i] = 0;
        
        if (!T.count(s + st)) return -1;
        int x = T[s + st];
        s[i] = '(';
        
        int y = calc(i + 1, en - 1);
        if (y == -1) return -1;
        
        if (!can[y][x]) return -1;
        return x;
        
    } else {
        char c = s[en + 1];
        s[en + 1] = 0;
        if (!V.count(s + st)) return -1;
        int x = V[s + st];
        s[en + 1] = c;
        return a[x];
    }
}

bool solve() {
    scanf("%d", &n);
    
    int i, j, k, v, t;
    
    int flg = 0;
    for (i = 1; i <= n; i++) {
        scanf("%s", s);
        if (V.count(s)) flg = 1;
        v = VHash(s);
        
        scanf("%s", s);
        t = THash(s);
        a[v] = t;
    }
    
    int m;
    scanf("%d", &m);
    for (i = 0; i < m; i++) {
        scanf("%s", s);
        b[i] = THash(s);
        scanf("%d", &k);
        
        con[i].clear();
        for (j = 0; j < k; j++) {
            scanf("%d", &v);
            con[i].pb(v);
        }
    }
    
    scanf("%s", s);
    if (flg) return 0;
    
    for (i = 1; i <= n; i++) {
        for (k = 0; k < m; k++) if (a[i] == b[k]) break;
        if (k == m) return 0;
    }
    for (k = 0; k < m; k++) {
        for (j = k + 1; j < m; j++) if (b[j] == b[k]) return 0;
    }
    for (k = 0; k < m; k++) {
        if (V.count(TV[k])) return 0;
    }
    
    for (k = 0; k < m; k++) {
        for (j = 0; j < m; j++) can[b[k]][j] = 0;
        can[b[k]][b[k]] = 1;
        
        for (j = 0; j < sz(con[k]); j++) {
            can[b[k]][b[con[k][j] - 1]] = 1;
        }
    }
    
    int ans = calc(0, strlen(s) - 1);
    if (ans == -1) return 0;
    else printf("%s\n", TV[ans - 1].c_str());
    return 1;
}

void init() {
    T.clear();
    V.clear();
    TV.clear();
    
    tcnt = vcnt = 0;
}

int main() {
    
    int T;
    for (scanf("%d", &T); T--; ) {
        init();
        if (!solve()) puts("-1");
    }
        
    return 0;
}