#include <cstdio>

#include <algorithm>

#include <vector>

#include <queue>

#include <cstring>

using namespace std;

const int INF=0x3f3f3f3f;

const int MAX_V=1000;

struct edge{int to,cap,rev;};

vector<edge> G[MAX_V];

int level[MAX_V],iter[MAX_V];

void add_edge(int from,int to,int cap){

    G[from].push_back((edge){to,cap,G[to].size()});

    G[to].push_back((edge){from,0,G[from].size()-1});

}

void bfs(int s){

    memset(level,-1,sizeof(level));

    queue<int> que;

    level[s]=0;

    que.push(s);

    while(!que.empty()){

        int v=que.front(); que.pop();

        for(int i=0;i<G[v].size();i++){

            edge &e=G[v][i];

            if(e.cap>0&&level[e.to]<0){

                level[e.to]=level[v]+1;

                que.push(e.to);

            }

        }

    }

}

int dfs(int v,int t,int f){

    if(v==t)return f;

    for(int &i=iter[v];i<G[v].size();i++){

        edge &e=G[v][i];

        if(e.cap>0&&level[v]<level[e.to]){

            int d=dfs(e.to,t,min(f,e.cap));

            if(d>0){

                e.cap-=d;

                G[e.to][e.rev].cap+=d;

                return d;

            }

        }

    }return 0;

}

int max_flow(int s,int t){

    int flow=0;

    for(;;){

        bfs(s);

        if(level[t]<0)return flow;

        memset(iter,0,sizeof(iter));

        int f;

        while((f=dfs(s,t,INF))>0){

            flow+=f;

        }

    }

}

int N,F,D;

int f[110],d[110];

int main(){

    scanf("%d%d%d",&N,&F,&D);

    for(int i=0;i<=N*2+F+D+1;i++)G[i].clear();

    for(int x=1;x<=F;x++)add_edge(0,x+N*2,1);

    for(int x=1;x<=D;x++)add_edge(x+N*2+F,N*2+F+D+1,1);

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

        scanf("%d%d",&f[i],&d[i]);

        for(int j=1;j<=f[i];j++){

            int x;

            scanf("%d",&x);

            add_edge(x+N*2,i,1);

        }

        for(int j=1;j<=d[i];j++){

            int x;

            scanf("%d",&x);

            add_edge(i+N,x+N*2+F,1);

        }add_edge(i,i+N,1);

    }printf("%d\n",max_flow(0,N*2+F+D+1));

    return 0;

}