Xzz is playing a MMORPG "human life".

In this game, there are N different skills. Some skills may base on another skill.

Learning skill will cost Xzz some money.

And there are M different jobs. If Xzz's skills satisfy the job's requirement, then Xzz can get this job, and get some money.

But some jobs are conflict, some Xzz can't get the job at same time.

There are K pairs of jobs are conflict.

Now Xzz want to know the money he can get at the most，can you help him.

First line of the input file contains an integer T(0 < T ≤ 10) that indicates how many cases of inputs are there.

The description of each case is given below:

The first line of each input case contains number N, M, K. N <= 100, M <= 50, K <= 5.

Then follow N lines. In ith line the first two number ? ,? , means learning skill i const vi , skill i base on another ni skills. The last ni number aij means before learning skill i Xzz need to learn skill aij. 0 ≤ vi ≤ 1000, 0 ≤ ni ≤ N

Then follow M lines. In ith line the first two number wi, mi , means job i earn wi, jobs i base on mi skills. The last mi number bij means get job i need to learn skill bij. 0 ≤ wi ≤ 1000, 0 ≤ mi ≤ M

Then follow K lines. In ith line the first two number ci, di, means job ci conflict with job di.

The description of output for each test case is given below:

The first line of the output for each test case contains number answer, the maximum money Xzz can get.

 #include <cstdio>

 #include <cstring>

 #include <queue>

 #include <cmath>

 #include <algorithm>

 #include <set>

 #include <iostream>

 #include <map>

 #include <stack>

 #include <string>

 using namespace std;

 #define pi acos(-1.0)

 #define eps 1e-6

 #define fi first

 #define se second

 #define lson l,m,rt<<1

 #define rson m+1,r,rt<<1|1

 #define bug      printf("******")

 #define mem(a,b) memset(a,b,sizeof(a))

 #define fuck(x)  cout<<"["<<x<<"]"<<endl

 #define f(a)     a*a

 #define san(n,m) scanf("%d%d",&n,&m)

 #define FIN freopen("in.txt","r",stdin)

 #define lowbit(x) x&-x

 #pragma comment (linker,"/STACK:102400000,102400000")

 using namespace std;

 const int maxn = ;

 typedef long long LL;

 const int MX = ;

 const int MXE =  * MX * MX;

 const LL INFLL = 0x3f3f3f3f3f3f3f3fLL;

 const int INF = 0x3f3f3f;

 struct MaxFlow {

     struct Edge {

         int v, nxt;

         LL w;

     } E[MXE];

     int tot, num, s, t;

     int head[MX];

     void init() {

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

         tot = ;

     }

     void add (int u, int v, LL w) {

         E[tot] = (Edge) {

             v, head[u], w

         };

         head[u] = tot++;

         E[tot] = (Edge) {

             u, head[v],

         };

         head[v] = tot++;

     }

     int  d[MX], vis[MX], gap[MX];

     void bfs() {

         memset (d, , sizeof (d) );

         memset (gap, , sizeof (gap) );

         memset (vis, , sizeof (vis) );

         queue<int>q;

         q.push (t);

         vis[t] = ;

         while (!q.empty() ) {

             int u = q.front();

             q.pop();

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

                 int v = E[i].v;

                 if (!vis[v]) {

                     d[v] = d[u] + ;

                     gap[d[v]]++;

                     q.push (v);

                     vis[v] = ;

                 }

             }

         }

     }

     int last[MX];

     LL dfs (int u, LL f) {

         if (u == t) return f;

         LL sap = ;

         for (int i = last[u]; ~i; i = E[i].nxt) {

             int v = E[i].v;

             if (E[i].w >  && d[u] == d[v] + ) {

                 last[u] = i;

                 LL tmp = dfs (v, min (f - sap, E[i].w) );

                 E[i].w -= tmp;

                 E[i ^ ].w += tmp;

                 sap += tmp;

                 if (sap == f) return sap;

             }

         }

         if (d[s] >= num) return sap;

         if (! (--gap[d[u]]) ) d[s] = num;

         ++gap[++d[u]];

         last[u] = head[u];

         return sap;

     }

     LL solve (int st, int ed, int n) {

         LL flow = ;

         num = n;

         s = st;

         t = ed;

         bfs();

         memcpy (last, head, sizeof (head) );

         while (d[s] < num) flow += dfs (s, INFLL);

         return flow;

     }

 } F;

 int t, n, m, k, vis[];

 struct node {

     int val, n;

     int num[];

 } a[], b[];

 struct node1 {

     int x, y;

 } p[maxn];

 int main() {

     scanf("%d", &t);

     while(t--) {

         scanf("%d%d%d", &n, &m, &k);

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

             scanf("%d%d", &a[i].val, &a[i].n);

             for (int j =  ; j < a[i].n ; j++) scanf("%d", &a[i].num[j]);

         }

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

             scanf("%d%d", &b[i].val, &b[i].n);

             for (int j =  ; j < b[i].n ; j++) scanf("%d", &b[i].num[j]);

         }

         for (int i =  ; i < k ; i++) scanf("%d%d", &p[i].x, &p[i].y);

         int st = , ed = n + m + ;

         LL ans = ;

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

             LL sum = ;

             F.init();

             memset(vis, , sizeof(vis));

             for (int j =  ; j < k ; j++) {

                 if (vis[p[j].x] && vis[p[j].y] ) continue;

                 if ((i >> j) & ) vis[p[j].y] = ;

                 else vis[p[j].x] = ;

             }

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

                 if (vis[j]) continue;

                 sum += 1LL * b[j].val;

                 F.add(st, j, b[j].val);

                 for (int p =  ; p < b[j].n ; p++) F.add(j, m + b[j].num[p], INF);

             }

             for (int j =  ; j <= n ; j++) {

                 F.add(m + j, ed, a[j].val);

                 for (int p =  ; p < a[j].n ; p++) F.add(m + j, m + a[j].num[p], INF);

             }

             LL temp = F.solve(st, ed, n + m + );

             ans = max(ans, sum - temp);

         }

         printf("%lld\n", ans);

     }

     return ;

 }