#include<bits/stdc++.h>
using namespace std;


#define MAX 500009
#define DR if(0)
#define DRU DR printf
#define PI 4

int odw[MAX];
list<int> syn[MAX];
int s[MAX],o[MAX];
list<int> ojc[MAX];
int nal[MAX];///1 kandydat 2 pewny
bool us[MAX];
int from[MAX];
int to[MAX];
bool zatw[MAX];
list<int> cykl[PI];
vector<int> dobre;
bool comp(int a, int b){
    return odw[a]<odw[b];
}
void usun(int n){///usuwa syf z grafu
    list<int>  bezdz,sier;
    list<int>::iterator it;
    int i,ob,pier;
    for(i=1;i<=n;i++)
    {
        s[i]=syn[i].size();
        o[i]=ojc[i].size();
        if(s[i]==0)
        {
            DRU("usuwamy %d\n" ,i);
            us[i]=true;
            bezdz.push_back(i);
        }
        if(o[i]==0)
        {
            DRU("usuwamy %d\n" ,i);
            us[i]=true;
            sier.push_back(i);
        }
    }
    while(bezdz.empty()==false||sier.empty()==false)
    {
        if(bezdz.empty()==false)
        {
            ob=bezdz.front();
            bezdz.pop_front();
            for(it=ojc[ob].begin();it!=ojc[ob].end();it++)
            {
                s[*it]--;

                if(s[*it]==0&&us[*it]==0)
                {
                    DRU("usuwamy %d\n" ,*it);
                    bezdz.push_back(*it);
                    us[*it]=1;
                }
            }
        }
        if(sier.empty()==false)
        {
            ob=sier.front();
            sier.pop_front();
            for(it=syn[ob].begin();it!=syn[ob].end();it++)
            {
                o[*it]--;
                DRU("ob %d it=%d o[it]=%d\n" ,ob,*it,o[*it]);
                if(o[*it]==0&&us[*it]==0)
                {
                    DRU("usuwamy %d\n" ,*it);
                    sier.push_back(*it);
                    us[*it]=1;
                }
            }
        }
    }
    for(i=1;i<=n;i++)
    {
        if(us[i]==false)
        {
            pier=ojc[i].front();
            ojc[i].pop_front();
            ojc[i].push_back(pier);
            while(ojc[i].front()!=pier)
            {
                ob=ojc[i].front();
                ojc[i].pop_front();
                if(us[ob]==false)
                    ojc[i].push_back(ob);
            }
            if(us[ojc[i].front()]==1)
                ojc[i].pop_front();

            pier=syn[i].front();
            syn[i].pop_front();
            syn[i].push_back(pier);
            while(syn[i].front()!=pier)
            {
                ob=syn[i].front();
                syn[i].pop_front();
                if(us[ob]==false)
                    syn[i].push_back(ob);
            }
            if(us[syn[i].front()]==1)
                syn[i].pop_front();
        }
    }
}
void randomizuj(int n)///to zaraz
{
    int i;
    vector<int> pomoc;
    vector<int>::iterator vit;
    list<int>::iterator it;
    for(i=1;i<=n;i++)
    {
        if(us[i]==0)
        {
            pomoc.clear();
            for(it=syn[i].begin();it!=syn[i].end();it++)
                pomoc.push_back(*it);
            sort(pomoc.begin(),pomoc.end(),comp);
            syn[i].clear();
            for(vit=pomoc.begin();vit!=pomoc.end();vit++)
                syn[i].push_back(*vit);
        }
    }
}
void dfs1(int ob, int ind){
    list<int>::iterator it;
    odw[ob]=ind;
    for(it=syn[ob].begin();it!=syn[ob].end();it++)
        if(odw[*it]!=ind)
            dfs1(*it,ind);
}
bool bfs(int kt, int n, int ind, int c){
    bool br=0;
    list<int> kol;
    list<int>::iterator it;
    kol.push_back(kt);
    odw[kt]=ind;
    int pier;
    while(kol.empty()==false)
    {

        kt=kol.front();
        DRU("bfs ob %d\n",kt);
        kol.pop_front();
        odw[kt]=ind;
        for(it=syn[kt].begin();it!=syn[kt].end();it++)
        {
            DRU("    to %d odw[]=%d (ind =%d)\n" ,*it,odw[*it],ind);
            if(odw[*it]==ind)
            {
                from[*it]=kt;
                pier=*it;
                while(kt!=pier)
                {
                    cykl[c].push_back(kt);
                    kt=from[kt];
                }
                cykl[c].push_back(kt);
                return 0;
            }
            else
            {
                from[*it]=kt;
                kol.push_back(*it);

            }
        }
    }
    return 1;
}
int dfs(int ob,int pop, int n,int ind, int c){
    list<int>::iterator it;
    odw[ob]=ind;
    from[ob]=pop;
    int kt;
    for(it=syn[ob].begin();it!=syn[ob].end();it++)
        if(odw[*it]==ind)
        {
            while(ob!=*it)
            {
                cykl[c].push_back(ob);
                ob=from[ob];
            }
            cykl[c].push_back(*it);
            return 1;
        }
    dfs(syn[ob].front(),ob,n,ind,c);
    return 0;
}
void scal(){
    bool sk=0;
    int i,pop=-1,il=0;
    list<int> wyn;
    list<int>::iterator it;
    for(i=0;i<PI;i++)
        cykl[i].sort();


    for(i=0;i<PI;i++)
        cykl[i].sort();
    wyn=cykl[0];
    for(i=1;i<PI;i++)
        wyn.merge(cykl[i]);
    cykl[0].clear();
    for(it=wyn.begin();it!=wyn.end();it++)
    {
        DRU("(%d)\n" ,*it);
        if(*it==pop)
        {

            il++;
            //DRU("wart %d il %d\n" ,*it,il);
            if(il==PI)
                cykl[0].push_back(*it);
        }
        else
        {
            pop=*it;
            il=1;
        }
    }
    DR
    {
        printf("kandydaci\n");
        for(it=cykl[0].begin();it!=cykl[0].end();it++)
            printf("%d " ,*it);
        printf("\n");
    }

}
bool istn(int zak, int n)///czy istnieje cykl z zakazanym zak
{
    DRU("istn zak %d n %d\n" ,zak,n);
    list<int> kol;
    list<int>::iterator it;
    int i,ob,il=0;
    for(i=0;i<n;i++)
        o[dobre[i]]=ojc[dobre[i]].size();
    for(it=syn[zak].begin();it!=syn[zak].end();it++)
        o[*it]--;
    DR
    {
        for(i=1;i<13;i++)
            printf("i %d o[i] %d us %d\n" ,i,o[i],us[i]);
        printf("\n\n");
    }
    for(i=0;i<n;i++)
        if(us[dobre[i]]==0)
            if(o[dobre[i]]==0)
            {
                DRU("wrzucamy %d\n" ,dobre[i]);
                kol.push_back(dobre[i]);
            }
    while(kol.empty()==false)
    {
        ob=kol.front();
        kol.pop_front();
        il++;
        DRU("istn zak %d ob %d\n" ,zak,ob);
        for(it=syn[ob].begin();it!=syn[ob].end();it++)
        {
            if(*it!=zak)
            {
                o[*it]--;
                if(o[*it]==0)
                {
                    DRU("   wrzucamy %d\n" ,*it);
                    kol.push_back(*it);
                }
            }
        }
    }
    if(il==n-1)
    {
        DRU("bez %d nie ma cykli il %d n %d\n" ,zak,il,n);
        return 1;
    }
    DRU("bez %d są cykle il %d n %d\n" ,zak,il,n);
    return 0;
}
int main()
{
    list<int> wyn;
    int n,m,i,j,il=0,a,b,r,ob;
    list<int>::iterator it;
    scanf("%d%d" ,&n,&m);
    for(i=0;i<m;i++)
    {
        scanf("%d%d" ,&a,&b);
        syn[a].push_back(b);
        ojc[b].push_back(a);
    }
    usun(n);
    for(i=1;i<=n;i++)
        if(odw[i]==0&&us[i]==false)
        {
            il++;
            dfs1(i,i);
        }
    if(il==0)
    {
        printf("NIE\n");
        return 0;
    }
    if(il!=1)
    {
        printf("0\n");
        return 0;
    }
    il=0;
    for(i=1;i<=n;i++)
    {
        if(us[i]==false)
        {
            DRU("%d dobry\n" ,i);
            dobre.push_back(i);
            il++;
        }
        else
            DRU("%d zly\n" ,i);

    }
    if(il==0)
    {
        printf("0\n");
        return 0;
    }
    for(i=0;i<PI;i++)
    {
        if(i)
            randomizuj(n);
        r=rand()%il;
        DRU("rand=%d,il %d wart %d\n" ,r,il, dobre[r]);
        dfs(dobre[r],dobre[r],n,n+i,i);
        DR
        {
            printf("cykl %d\n" ,i);
            for(it=cykl[i].begin();it!=cykl[i].end();it++)
                printf("%d " ,*it);
            printf("\n");
        }
    }
    scal();
    for(it=cykl[0].begin();it!=cykl[0].end();it++)
    {
        if(zatw[*it]==0)
        {
            if(istn(*it,il))
            {
                zatw[*it]=1;
                wyn.push_back(*it);
                ob=*it;
                while(syn[ob].size()==1)
                {
                    ob=syn[ob].front();
                    if(zatw[ob])
                        break;
                    zatw[ob]=1;
                    wyn.push_back(ob);
                }
                ob=*it;
                while(ojc[ob].size()==1)
                {
                    ob=ojc[ob].front();
                    if(zatw[ob])
                        break;
                    zatw[ob]=1;
                    wyn.push_back(ob);
                }
            }
        }
    }
    if(wyn.empty())
    {
        printf("0\n");
        return 0;
    }
    wyn.sort();
    printf("%d\n" ,wyn.size());
    for(it=wyn.begin();it!=wyn.end();it++)
        printf("%d " ,*it);

}