#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;

const int maxN = 5e5 + 10;
const int maxM = 1e6 + 10;

vector<int>nbh[maxN];
vector<int>_nbh[maxN];
int edges[maxM][2];
int num[maxN];
int B[maxN];
int _B[maxN];
int n, m, who;

vector<int>ans;

void dfs_sort(int v) {
    B[v] = true;
    for(int a: nbh[v])
        if(!B[a])
            dfs_sort(a);
    ans.push_back(v);
}

int nr = 1;
void dfs_nr(int v) {
    B[v] = false;
    num[v] = nr;
    for(int a: _nbh[v])
        if(B[a])
            dfs_nr(a);
}

const int inf = 1e9;
int dep[maxN];
int dep_min = 0, dep_max = inf;
int from_main[maxN];
int ambiguous_add[maxN];
int ambiguous_rem[maxN];

void dfs_ambiguous(int v) {
//     printf("dfs: %d\n", v);
    B[v] = true;
    if(!from_main[v]) {
        bool is_first = true;
        for(int a: nbh[v]) {
            if(!B[a]) { // new
                if(!is_first)
                    from_main[a] = v;
                dep[a] = dep[v] + 1;
                is_first = false;
                dfs_ambiguous(a);
            } else if(!_B[a]) { // cycle
                dep_min = max(dep_min, dep[a]);
                ambiguous_add[v]++;
            } else { // touch
                if(from_main[a]) {
                    if(dep[from_main[a]] > dep[v]) {
                        ambiguous_add[v]++;
                        ambiguous_add[from_main[a]]--;
                    }
                } else {
                    ambiguous_rem[a]--;
                    ambiguous_add[v]++;
                }
            }
        }
    } else {
        for(int a: nbh[v]) {
            if(B[a] && !_B[a]) { // cycle
                ambiguous_add[from_main[v]]++;
                dep_min = max(dep_min, dep[a]);
            } else if(B[a]) { // touch
                if(!from_main[a])
                    ambiguous_rem[a]--;
                else
                    ambiguous_add[from_main[a]]--;
                ambiguous_add[from_main[v]]++;
            } else { // new
                from_main[a] = from_main[v];
                dep[a] = dep[v] + 1;
                dfs_ambiguous(a);
            }
        }
    }
    _B[v] = true;
}

int ambiguous_sum;
void dfs_ans(int v) {
    B[v] = false;
    ambiguous_sum += ambiguous_rem[v];
//     printf("%d: amb_sum:%d next:%d B_next:%d\n", v, ambiguous_sum, nbh[v][0], B[nbh[v][0]] ? 1 : 0);

    if(!ambiguous_sum)
        ans.push_back(v);
    ambiguous_sum += ambiguous_add[v];

    if(B[nbh[v][0]])
        dfs_ans(nbh[v][0]);
}

void clear() {
    ambiguous_sum = 0;
    dep_min = 0;
    for(int i = 1; i <= n; ++i) {
       B[i] = _B[i] = false;
       nbh[i].swap(_nbh[i]);
       from_main[i] = 0;
       ambiguous_add[i] = ambiguous_rem[i] = 0;
    }
}


/***************************** brutal ************************************/

void dfs_ambiguous_brute(int v) {
//     printf("dfs: %d\n", v);
    B[v] = 1;
    bool fst = true;
    for(int a: nbh[v]) {
        if(!B[a] && fst) {
            fst = false;
            dep[a] = dep[v] + 1;
            dfs_ambiguous_brute(a);
        } else if(B[a] && !_B[a]) {
            dep_max = min(dep_max, dep[v]);
            dep_min = max(dep_min, dep[a]);
        }
    }
    _B[v] = 1;
}


vector<int>all;

int act;
bool dfs_check(int v) {
    B[v] = act;
    for(int a: nbh[v]) {
        if(B[a] != act && dfs_check(a))
            return true;
        if(B[a] == act && _B[a] != act)
            return true;
    }
    _B[v] = act;
    return false;
}

bool check(int x) {
    act = x + n;
    B[x] = _B[x] = act;
    for(int i: all) {
        if(B[i] != act && dfs_check(i))
            return false;
    }
    return true;
}

void gen_ans() {
    dep[who] = 1;
    dfs_ambiguous_brute(who);
//     printf("min: %d max: %d\n", dep_min, dep_max);
    if(dep_min > dep_max) {
        printf("0\n\n");
        exit(0);
    }
    int x = who, next = who;
    while(dep[x] <= dep_max) {
//         printf("-- %d --\n", x);
        if(dep[x] >= dep_min && check(x))
            ans.push_back(x);
        if(dep[x] == dep_max)
            break;
        for(int i = 0; dep[next] <= dep[x]; ++i)
            next = nbh[x][i];
        x = next;
    }
}

void el_brute() {
    gen_ans();
    sort(ans.begin(), ans.end());
}

/*********************************** heural *************************************/

void el_heurezone() {
        dfs_ambiguous(who);
    dfs_ans(who);
    for(int& a: ans)
        if(dep[a] < dep_min)
            a = inf;
    clear();
    dfs_ambiguous(who);
    dfs_ans(who);
    for(int& a: ans)
        if(a < inf && dep[a] < dep_min)
            a = inf;
    sort(ans.begin(), ans.end());
    while(!ans.empty() && ans.back() == inf)
        ans.pop_back();
    int prev = -1;
    for(int& a: ans) {
        if(a == prev)
            a = inf;
        else
            prev = a;
    }

    sort(ans.begin(), ans.end());
    while(!ans.empty() && ans.back() == inf)
        ans.pop_back();
}

int main() {
    scanf("%d%d", &n, &m);
    for(int i = 0; i < m; ++i) {
        scanf("%d%d", edges[i], edges[i] + 1);
        nbh[edges[i][0]].push_back(edges[i][1]);
        _nbh[edges[i][1]].push_back(edges[i][0]);
    }
    for(int i = 1; i <= n; ++i)
        if(!B[i])
            dfs_sort(i);
    while(ans.size()) {
        if(B[ans.back()]) {
            nr = ans.back();
            dfs_nr(ans.back());
        }
        ans.pop_back();
    }
    int sum = 0;
    for(int i = 1; i <= n; ++i) {
        if(num[i] != i && !B[num[i]]) {
            B[who = num[i]] = true;
            sum++;
        }
    }
//     printf("sum = %d\n", sum);
    if(sum == 0) {
        printf("NIE\n");
        return 0;
    }
    if(sum > 1) {
//         printf("0\n");
        printf("0\n\n");
        return 0;
    }

    B[who] = false;
    for(int i = 1; i <= n; ++i) {
        nbh[i].clear();
        _nbh[i].clear();
    }
    int _m = 0;
    for(int a, b, i = 0; i < m; ++i) {
        a = edges[i][0];
        b = edges[i][1];
        if(num[a] == num[b]) {
            nbh[a].push_back(b);
            _nbh[b].push_back(a);
            _m++;
        }
    }
    dep[who] = 1;
    for(int i = 1; i <= n; ++i) {
        if(num[i] == who) {
            all.push_back(i);
        }
    }

    if(all.size() * _m <= 1e7)
        el_brute();
    else
        el_heurezone();
    printf("%d\n", (int) ans.size());
    for(int a: ans)
        printf("%d ", a);
    printf("\n");
    return 0;
}