/**

  * poj.org

  * Problem#1274

  * Accepted

  * Time:16ms

  * Memory:1980k

  */

 #include<iostream>

 #include<sstream>

 #include<cstdio>

 #include<cmath>

 #include<cstdlib>

 #include<cstring>

 #include<cctype>

 #include<ctime>

 #include<queue>

 #include<set>

 #include<map>

 #include<stack>

 #include<vector>

 #include<algorithm>

 using namespace std;

 typedef bool boolean;

 #define smin(a, b) (a) = min((a), (b))

 #define smax(a, b) (a) = max((a), (b))

 #define INF 0xfffffff

 template<typename T>

 inline boolean readInteger(T& u){

     char x;

     int aFlag = ;

     while(!isdigit((x = getchar())) && x != '-' && ~x);

     if(!(~x))    return false;

     if(x == '-'){

         aFlag = -;

         x = getchar();

     }

     for(u = x - ''; isdigit((x = getchar())); u = u *  + x - '');

     ungetc(x, stdin);

     u *= aFlag;

     return true;

 }

 ///map template starts

 typedef class Edge{

     public:

         int end;

         int next;

         int cap;

         int flow;

         Edge(const int end = , const int next = , const int cap = , const int flow = ):end(end), next(next), cap(cap), flow(flow){}

 }Edge;

 typedef class MapManager{

     public:

         int ce;

         int *h;

         Edge *edge;

         MapManager(){}

         MapManager(int points, int limit):ce(){

             h = new int[(const int)(points + )];

             edge = new Edge[(const int)(limit + )];

             memset(h, , sizeof(int) * (points + ));

         }

         inline void addEdge(int from, int end, int cap, int flow){

             edge[++ce] = Edge(end, h[from], cap, flow);

             h[from] = ce;

         }

         inline void addDoubleEdge(int from, int end, int cap){

             addEdge(from, end, cap, );

             addEdge(end, from, cap, cap);

         }

         Edge& operator [](int pos){

             return edge[pos];

         }

         inline int reverse(int pos){        //反向边

             return (pos & ) ? (pos + ) : (pos - );

         }

         inline void clear(){

             delete[] edge;

             delete h;

             ce = ;

         }

 }MapManager;

 #define m_begin(g, i)     (g).h[(i)]

 #define m_end(g, i)     (g).edge[(i)].end

 #define m_next(g, i)     (g).edge[(i)].next

 #define m_cap(g, i)     (g).edge[(i)].cap

 #define m_flow(g, i)     (g).edge[(i)].flow

 ///map template ends

 int n, m;

 int t;

 MapManager g;

 inline boolean init(){

     if(!readInteger(n))    return false;

     readInteger(m);

     t = n + m + ;

     g = MapManager(t + , (n + ) * (m + ) * );

     for(int i = , a, b; i <= n; i++){

         readInteger(a);

         while(a--){

             readInteger(b);

             g.addDoubleEdge(i, b + n, );

         }

     }

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

         g.addDoubleEdge(, i, );

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

         g.addDoubleEdge(i + n, t, );

     return true;

 }

 boolean *visited;

 int* divs;

 queue<int> que;

 inline boolean getDivs(){

     memset(visited, false, sizeof(boolean) * (t + ));

     divs[] = ;

     visited[] = true;

     que.push();

     while(!que.empty()){

         int e = que.front();

         que.pop();

         for(int i = m_begin(g, e); i != ; i = g[i].next){

             int& eu = g[i].end;

             if(!visited[eu] && g[i].flow < g[i].cap){

                 divs[eu] = divs[e] + ;

                 visited[eu] = true;

                 que.push(eu);

             }

         }

     }

     return visited[t];

 }

 int blockedflow(int node, int minf){

     if(node == t || minf == )    return minf;

     int f, flow = ;

     for(int i = m_begin(g, node); i != ; i = m_next(g, i)){

         int& e = g[i].end;

         if(divs[e] == divs[node] +  && visited[e] && (f = blockedflow(e, min(minf, g[i].cap - g[i].flow))) > ){

             flow += f;

             g[i].flow += f;

             g[g.reverse(i)].flow -= f;

             minf -= f;

             if(minf == )    return flow;

         }

     }

     return flow;

 }

 inline int maxflow(){

     visited = new boolean[(const int)(t + )];

     divs = new int[(const int)(t + )];

     int res = ;

     while(getDivs()){

         res += blockedflow(, INF);

     }

     return res;

 }

 inline void solve(){

     int res = maxflow();

     cout << res << endl;

 }

 inline void clear(){

     delete[] visited;

     delete[] divs;

     g.clear();

 }

 int main(){

     while(init()){

         solve();

         clear();

     }

     return ;

 }