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 = 0; i <= m; i++)
            {
                Size[i] = 0;
                up[i] = down[i] = i; //each column point to itself
                left[i] = i-1; //row point to their neighbor
                right[i] = i+1;
            }
            right[m] = 0;
            left[0] = m; //circulate link
            size = m;
            for(int i = 1; i <= n; i++)
                Head[i] = -1;
        }
        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] < 0) 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[0] == 0)
            {
                ansd = d;
                return true;
            }

            int c = right[0];
            for(int i = right[0]; i != 0; 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+1)) 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 = 1; i <= n; i++)
        {
            int t;
            scanf("%d",&t);
            for(int j = 1; j <= t; j++)
            {
                int num;
                scanf("%d",&num);
                g.Link(i,num);
            }
        }
        if( !g.dance(0))
            printf("NO
");
        else
        {
            printf("%d ",g.ansd);
            for(int i = 0; i < g.ansd; i++)
            {
                printf("%d%c",g.ans[i],i == g.ansd - 1?'
':' ');
            }
        }

    }

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