DLX

     #include <iostream>
     #include <cstdlib>
     #include <cstring>
     #include <queue>
     #include <cstdio>
     #include <algorithm>
     #include <map>
     #define LL long long

     using namespace std;

     const int N = 2e5,M = 2e3;

     struct DLX
     {
         int n,m,size;
         int up[N],down[N],right[N],left[N],row[N],col[N]; //four pointer and the coordinate of nodes
         int Head[M],Size[M]; //head pointer and the size of each linkList
         int ans[M],ansd;
         void init(int _n,int _m) //initialize the head line node
         {
             n = _n;
             m = _m;
             for(int i = ; i <= m; i++)
             {
                 Size[i] = ;
                 up[i] = down[i] = i; //each column point to itself
                 left[i] = i-; //row point to their neighbor
                 right[i] = i+;
             }
             right[m] = ;
             left[] = m; //circulate link
             size = m;
             for(int i = ; i <= n; i++)
                 Head[i] = -;
         }
         void Link(int r,int c) //modify the four pointer
         {
             ++Size[col[++size]=c];
             row[size] = r;
             down[size] = down[c];
             up[down[c]] = size;
             up[size] = c;
             down[c] = size;

             if(Head[r] < ) Head[r] = left[size] = right[size] = size;
             else
             {
                 right[size] = right[Head[r]];
                 left[right[Head[r]]] = size;
                 left[size] = Head[r];
                 right[Head[r]] = size;
             }
         }

         void remove(int c) //delete the column
         {
             left[right[c]] = left[c];
             right[left[c]] = right[c];
             for(int i = down[c]; i != c;i = down[i])
                 for(int j = right[i]; j != i; j = right[j])
             {
                 up[down[j]] = up[j];
                 down[up[j]] = down[j];
                 --Size[col[j]];
             }
         }

         void resume(int c)
         {

             for(int i = up[c]; i != c; i = up[i])
                 for(int j = left[i]; j != i; j = left[j])
             {
                 ++Size[col[up[down[j]]=down[up[j]]=j]];
             }
             left[right[c]] = right[left[c]] = c;
         }

         bool dance(int d) //the depth
         {
             if(right[] == )
             {
                 ansd = d;
                 return true;
             }

             int c = right[];
             for(int i = right[]; i != ; i = right[i])
             {
                 //if(Size[i] == 0) return false;
                 if(Size[i] < Size[c])
                     c = i;
             }
             remove(c);
             for(int i = down[c]; i != c; i = down[i])
             {
                 ans[d] = row[i];
                 for(int j = right[i]; j != i; j = right[j]) remove(col[j]);
                 if(dance(d+)) return true;
                 for(int j = left[i]; j != i; j = left[j]) resume(col[j]);
             }
             resume(c);
             return false;
         }
     };

     DLX g;

     void solve(int n,int m)
     {
        // int n,m;
         // scanf("%d %d",&n,&m);

         g.init(n,m);
         for(int i = ; i <= n; i++)
         {
             int t;
             scanf("%d",&t);
             for(int j = ; j <= t; j++)
             {
                 int num;
                 scanf("%d",&num);
                 g.Link(i,num);
             }
         }
         if( !g.dance())
             printf("NO\n");
         else
         {
             printf("%d ",g.ansd);
             for(int i = ; i < g.ansd; i++)
             {
                 printf("%d%c",g.ans[i],i == g.ansd - ?'\n':' ');
             }
         }

     }

     int main(void)
     {
         int n,m;
         while(scanf("%d %d",&n,&m) != -)
         {
             solve(n,m);
         }
         return ;
     }