#include<bits/stdc++.h>
using namespace std;
int A , C , T;
vector<int> a_c[50005] , a_t[50005] , c_t[50005];
vector<int> c_a[50005];
bool in(int t,int c)
{
    for(auto x : c_t[c]) {
        if(x == t) return 1;
    }
    return 0;
}
struct node {
    int a , c, t;
};
bool operator < (node a,node b)
{
    if(a.a == b.a) {
        if(a.c == b.c) return a.t < b.t;
        return a.c < b.c;
    }
    return a.a < b.a;
}
bool operator == (node a,node b)
{
    return (a.a == b.a && a.c == b.c && a.t == b.t);
}
map<node,int> mp;
vector<int> E[200005];
int tp[200005];
void add(int u,int v)
{
   // printf("%d %d\n",u,v);
   assert(u != v);
    E[u].push_back(v);
}
void dfs(int u)
{
    for(auto v : E[u]) {
        if(tp[v] == -1) {
            tp[v] = !tp[u];
            dfs(v);
        }
       // assert(tp[v] == !tp[u]);
    }
    return;
}

namespace net {
    const int N = 2e5 + 10;
    namespace flow{
        const int inf = numeric_limits<int>::max();
        struct Q {
            int v ;
            int w;
            int id;
        };
        vector<Q> e[N];
        int fc[N],q[N];
        int n,s,t;
        int bfs(){
            fill_n(fc,n,0);
            int p1=0,p2=0,u;
            fc[s]=1,q[0]=s;
            while(p1<=p2){
                int u=q[p1++];
                for(auto&[v,w,id]:e[u])if(w&&!fc[v])fc[q[++p2]=v]=fc[u]+1;
            }
            return fc[t];
        }
        int dfs(int u,int maxf){
            if(u==t)return maxf;
            int j=0,k;
            for(auto&[v,w,id]:e[u])if(w&&fc[v]==fc[u]+1&&(k=dfs(v,min(maxf-j,w)))){
                j+=k,w-=k;
                e[v][id].w+=k;
                if(j==maxf)return j;
            }
            fc[u]=0;
            return j;
        }
        int max_flow(const vector<tuple<int,int,int>>& edges,int S,int T){
            s=S,t=T,n=max(s,t);
            for(auto[u,v,w]:edges)n=max({n,u,v});
            ++n;
            for(int i=0;i<n;++i)e[i].clear();
            for(auto[u,v,w]:edges)if(u!=v){
                e[u].push_back({v,w,e[v].size()});
                e[v].push_back({u,0,e[u].size()-1});
            }
            int r=0;
            while(bfs())r+=dfs(s,inf);
            return r;
        }
    }
    using flow::max_flow,flow::fc;
}
vector<tuple<int,int,int> > edges;
void adde(int u,int v)
{
    edges.push_back((tuple<int,int,int>){u,v,1});
}
int main()
{
  //  freopen("in.txt","r",stdin);
    cin >> A >> C >> T;
    for(int i = 1;i <= A;i++) {
        int L ; cin >> L;
        for(int j = 1;j <= L;j++) {
            int x;cin >> x;a_c[i].push_back(x);
            c_a[x].push_back(i);
        }
    }
    for(int i = 1;i <= A;i++) {
        int L ; cin >> L;
        for(int j = 1;j <= L;j++) {
            int x;cin >> x;a_t[i].push_back(x);
        }
    }
    for(int i = 1;i <= C;i++) {
        int L;cin >> L;
        for(int j = 1;j <= L;j++) {
            int x;cin >> x;c_t[i].push_back(x);
        }
    }
    int cnt = 0;
    for(int i = 1;i <= A;i++) {
        for(auto &con : a_c[i]) {
            for(auto &task : a_t[i]) {
                if(in(task , con)) {
                    node u;u.a = i;u.c = con;u.t = task;
                    mp[u] = ++cnt;
                }
            }
        }
    }
    for(auto &[x,y] : mp) {
    //    printf("N %d %d %d , %d\n",x.a,x.c,x.t,y);
        for(auto t : c_t[x.c]) {
            node u2 = x;u2.t = t;
            if(u2 == x) continue;
            if(mp.find(u2) != mp.end()) add(y , mp[u2]);
        }
        for(auto c : a_c[x.a]) {
            node u2 = x;u2.c = c;
            if(u2 == x) continue;
            if(mp.find(u2) != mp.end()) add(y , mp[u2]);
        }
        for(auto a : c_a[x.c]) {
            node u2 = x;u2.a = a;
            if(u2 == x) continue;
            if(mp.find(u2) != mp.end()) add(y , mp[u2]);
        }
    }
    for(int i = 1;i <= cnt;i++) tp[i] = -1;
    for(int i = 1;i <= cnt;i++) {
        if(tp[i] == -1) {tp[i] = 0;dfs(i);}
    }
    for(int i = 1;i <= cnt;i++) {
        if(tp[i] == 0) adde(0 , i);
        else adde(i , cnt + 1);
        if(tp[i] == 0) {
            for(auto v : E[i]) if(tp[v] != tp[i]) adde(i , v);
        }
    }
    cout << cnt - net::max_flow(edges , 0 , cnt + 1) << '\n';
    return 0;
}