#include <iostream>

 #include <cstdio>

 #include <cstring>

 #include <algorithm>

 #include <vector>

 #include <queue>

 using namespace std;

 const int maxn =  + ;

 const int maxnode =  + ;

 const int INF = 0x3f3f3f3f;

 int N, F, D;

 int n, s, t;

 struct Edge

 {

     int from, to, cap, flow;

     Edge(int u, int v, int c, int f):from(u), to(v), cap(c), flow(f) {}

 };

 vector<Edge> edges;

 vector<int> G[maxnode];

 void init()

 {

     edges.clear();

     for(int i = ; i < n; i++) G[i].clear();

 }

 void AddEdge(int u, int v, int c)

 {

     edges.push_back(Edge(u, v, c, ));

     edges.push_back(Edge(v, u, , ));

     int m = edges.size();

     G[u].push_back(m - );

     G[v].push_back(m - );

 }

 bool vis[maxnode];

 int d[maxnode];

 int cur[maxnode];

 bool BFS()

 {

     d[s] = ;

     queue<int> Q;

     Q.push(s);

     memset(vis, false, sizeof(vis));

     vis[s] = true;

     while(!Q.empty())

     {

         int u = Q.front(); Q.pop();

         for(int i = ; i < G[u].size(); i++)

         {

             Edge& e = edges[G[u][i]];

             int v = e.to;

             if(!vis[v] && e.cap > e.flow)

             {

                 vis[v] = true;

                 d[v] = d[u] + ;

                 Q.push(v);

             }

         }

     }

     return vis[t];

 }

 int DFS(int u, int a)

 {

     if(u == t || a == ) return a;

     int flow = , f;

     for(int& i = cur[u]; i < G[u].size(); i++)

     {

         Edge& e = edges[G[u][i]];

         int v = e.to;

         if(d[v] == d[u] +  && (f = DFS(v, min(a, e.cap - e.flow))) > )

         {

             flow += f;

             e.flow += f;

             a -= f;

             edges[G[u][i]^].flow -= f;

             if(a == ) break;

         }

     }

     return flow;

 }

 int Maxflow()

 {

     int flow = ;

     while(BFS())

     {

         memset(cur, , sizeof(cur));

         flow += DFS(s, INF);

     }

     return flow;

 }

 int main()

 {

     while(scanf("%d%d%d", &N, &F, &D) == )

     {

         n = N *  + D + F + ;

         s = , t = n - ;

         init();

         //build graph

         for(int i = ; i <= F; i++) AddEdge(s, N*+i, );

         for(int i = ; i <= D; i++) AddEdge(N*+F+i, t, );

         for(int i = ; i <= N; i++) AddEdge(i, i + N, );

         for(int i = ; i <= N; i++)

         {

             int f, d, x; scanf("%d%d", &f, &d);

             while(f--)

             {

                 scanf("%d", &x);

                 AddEdge(N*+x, i, );

             }

             while(d--)

             {

                 scanf("%d", &x);

                 AddEdge(N + i, N*+F+x, );

             }

         }

         printf("%d\n", Maxflow());

     }

     return ;

 }