import java.io.*;
import java.util.*;

class kon {

    public static void main(String[] args) {

        FastScanner in = new FastScanner();
        FastWriter out = null;
        try {
            out = new FastWriter();
        } catch (FileNotFoundException e) {

        }
        int n = in.nextInt();
        int m =in.nextInt();
        int a,b;

        ArrayList<ArrayList<Integer>> adj = new ArrayList<>(n);
        for(int i = 0; i < n; ++i)
        {
            adj.add(new ArrayList<>());
        }

        for(int i = 0; i < m; ++i)
        {
            a = in.nextInt();
            b = in.nextInt();
            --a;
            --b;

            adj.get(a).add(b);
        }

        ElementaryCyclesSearch search = new ElementaryCyclesSearch(adj);
        /*Thread t = new Thread(null, null, "TT", 268435456) {
            @Override
            public void run() {
                search.getElementaryCycles();
            }

        };
        t.start();
        try {
            t.join();
        } catch (InterruptedException e) {

        }*/

        search.getElementaryCycles();
        HashMap<Integer, ElementaryCyclesSearch.MutableInt> map = search.map;

        if(search.totalCycles == 0)
        {
           out.println("NIE");
        }
        else {
            List<Integer> l = new ArrayList<>();

            for (Map.Entry<Integer, ElementaryCyclesSearch.MutableInt> entry : map.entrySet()) {
                if (entry.getValue().value == search.totalCycles)
                    l.add(entry.getKey());
            }


            Collections.sort(l);
            out.printNextln(l.size());
            for (int x : l) {
                out.printNext(x + 1);
            }

            out.println();
        }
        out.close();
    }
}

class FastWriter extends PrintWriter {
    FastWriter() throws FileNotFoundException {
        super(System.out);
    }

    void printNext(int i) {
        print(i);
        print(' ');
    }
    void printNextln(int i) {
        print(i);
        println();
    }

    void printNextln(String str) {
        print(str);
        println();
    }

}

class FastScanner {
    BufferedReader br;
    StringTokenizer st;


    boolean ready() throws IOException {
        return (br.ready() || st.hasMoreTokens());
    }

    FastScanner() {
        br = new BufferedReader(new InputStreamReader(System.in));
    }

    String next() {
        while (st == null || !st.hasMoreTokens()) {
            try {
                st = new StringTokenizer(br.readLine());
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return st.nextToken();
    }

    int nextInt() {
        return Integer.parseInt(next());
    }

    long nextLong() {
        return Long.parseLong(next());
    }

}

class ElementaryCyclesSearch {
    private int[][] adjList = null;
    private boolean[] blocked = null;
    private LinkedList<Integer>[] B = null;
    private Set<Integer>[] BSet = null;
    private Stack<Integer> stack = null;
    public HashMap<Integer, MutableInt> map = new HashMap<>();
    public int totalCycles = 0;

    public ElementaryCyclesSearch(ArrayList<ArrayList<Integer>> adjList)
    {
        this.adjList = new int[adjList.size()][];

        for(int i = 0; i < adjList.size(); i++)
        {
            ArrayList<Integer> l = adjList.get(i);
            this.adjList[i] = new int[adjList.get(i).size()];
            for(int j = 0; j < this.adjList[i].length; j++)
                this.adjList[i][j] = l.get(j);
        }
    }


    public HashMap<Integer, MutableInt> getElementaryCycles() {
        this.blocked = new boolean[this.adjList.length];
        this.BSet = new Set[this.adjList.length];
        this.B = new LinkedList[this.adjList.length];
        for(int i = 0; i < this.adjList.length; i++)
        {
            this.B[i] = new LinkedList<>();
            this.BSet[i] = new HashSet<>();
        }
        this.stack = new Stack<>();
        StrongConnectedComponents sccs = new StrongConnectedComponents(this.adjList);
        int s = 0;

        while (true) {
            SCCResult sccResult = sccs.getAdjacencyList(s);
            if (sccResult != null && sccResult.getAdjList() != null) {
                Vector[] scc = sccResult.getAdjList();
                s = sccResult.getLowestNodeId();
                for (int j = 0; j < scc.length; j++) {
                    if ((scc[j] != null) && (scc[j].size() > 0)) {
                        this.blocked[j] = false;
                        this.B[j].clear();
                        this.BSet[j].clear();
                    }
                }

                this.findCycles(s, s, scc);
                s++;
            } else {
                break;
            }
        }

        return map;
    }
    class MutableInt {
        int value = 1;
        public void increment () { ++value;      }
        public int  get ()       { return value; }
    }


    private boolean findCycles(int v, int s, Vector[] adjList) {
        boolean f = false;
        this.stack.push(v);
        this.blocked[v] = true;

        for (int i = 0; i < adjList[v].size(); i++) {
            int w = ((Integer) adjList[v].get(i)).intValue();
            if (w == s) {
                int x = 0;
                Stack<Integer> dummy = new Stack<>();
                while(!this.stack.empty())
                {
                    int index = stack.pop();
                    x++;
                    MutableInt count = map.get(index);
                    if(count == null)
                        map.put(index, new MutableInt());
                    else
                        count.increment();

                    dummy.push(index);
                }

                while(!dummy.isEmpty())
                {
                    stack.push(dummy.pop());
                }

                if(x > 0)
                    totalCycles++;

                f = true;
            } else if (!this.blocked[w]) {
                if (this.findCycles(w, s, adjList)) {
                    f = true;
                }
            }
        }

        if (f) {
            this.unblock(v);
        } else {
            for (int i = 0; i < adjList[v].size(); i++) {
                int w = ((Integer) adjList[v].get(i)).intValue();
                if (!this.BSet[w].contains(v)) {
                    this.B[w].add(v);
                    this.BSet[w].add(v);
                }
            }
        }

        this.stack.pop();
        return f;
    }

    private void unblock(int node) {
        this.blocked[node] = false;
        LinkedList Bnode = this.B[node];
        while (Bnode.size() > 0) {
            Integer w = (Integer) Bnode.getFirst();
            Bnode.removeFirst();
            BSet[node].remove(w);
            if (this.blocked[w.intValue()]) {
                this.unblock(w.intValue());
            }
        }
    }
}

class SCCResult {
    private HashSet<Integer> nodeIDsOfSCC = null;
    private Vector[] adjList = null;
    private int lowestNodeId = -1;

    public SCCResult(Vector[] adjList, int lowestNodeId) {
        this.adjList = adjList;
        this.lowestNodeId = lowestNodeId;
        this.nodeIDsOfSCC = new HashSet();
        if (this.adjList != null) {
            for (int i = this.lowestNodeId; i < this.adjList.length; i++) {
                if (this.adjList[i].size() > 0) {
                    this.nodeIDsOfSCC.add(new Integer(i));
                }
            }
        }
    }

    public Vector[] getAdjList() {
        return adjList;
    }

    public int getLowestNodeId() {
        return lowestNodeId;
    }
}

class StrongConnectedComponents {
    private int[][] adjListOriginal = null;
    private int[][] adjList = null;
    private boolean[] visited = null;
    private Stack<Integer> stack = null;
    private HashSet<Integer> onStack = new HashSet<>();
    private int[] lowlink = null;
    private int[] number = null;
    private int sccCounter = 0;
    private Vector currentSCCs = null;

    public StrongConnectedComponents(int[][] adjList) {
        this.adjListOriginal = adjList;
    }

    public SCCResult getAdjacencyList(int node) {
        this.visited = new boolean[this.adjListOriginal.length];
        this.lowlink = new int[this.adjListOriginal.length];
        this.number = new int[this.adjListOriginal.length];
        this.visited = new boolean[this.adjListOriginal.length];
        this.stack = new Stack<>();
        this.currentSCCs = new Vector();

        this.makeAdjListSubgraph(node);

        for (int i = node; i < this.adjListOriginal.length; i++) {
            if (!this.visited[i]) {
                this.getStrongConnectedComponents(i);
                HashSet<Integer> nodes = this.getLowestIdComponent();
                if (nodes != null && !nodes.contains(new Integer(node)) && !nodes.contains(new Integer(node + 1))) {
                    return this.getAdjacencyList(node + 1);
                } else {
                    Vector[] adjacencyList = this.getAdjList(nodes);
                    if (adjacencyList != null) {
                        for (int j = 0; j < this.adjListOriginal.length; j++) {
                            if (adjacencyList[j].size() > 0) {
                                return new SCCResult(adjacencyList, j);
                            }
                        }
                    }
                }
            }
        }

        return null;
    }

    private void makeAdjListSubgraph(int node) {
        this.adjList = new int[this.adjListOriginal.length][0];

        for (int i = node; i < this.adjList.length; i++) {
            Vector successors = new Vector();
            for (int j = 0; j < this.adjListOriginal[i].length; j++) {
                if (this.adjListOriginal[i][j] >= node) {
                    successors.add(new Integer(this.adjListOriginal[i][j]));
                }
            }
            if (successors.size() > 0) {
                this.adjList[i] = new int[successors.size()];
                for (int j = 0; j < successors.size(); j++) {
                    Integer succ = (Integer) successors.get(j);
                    this.adjList[i][j] = succ.intValue();
                }
            }
        }
    }

    private HashSet<Integer> getLowestIdComponent() {
        int min = this.adjList.length;
        HashSet<Integer> currScc = null;

        for (int i = 0; i < this.currentSCCs.size(); i++) {
            HashSet<Integer> scc = (HashSet<Integer>) this.currentSCCs.get(i);
            for(Integer node : scc)
            {
                if (node < min) {
                    currScc = scc;
                    min = node;
                }
            }
        }
        return currScc;
    }
    private Vector[] getAdjList(HashSet<Integer> nodes) {
        Vector[] lowestIdAdjacencyList = null;

        if (nodes != null) {
            lowestIdAdjacencyList = new Vector[this.adjList.length];
            for (int i = 0; i < lowestIdAdjacencyList.length; i++) {
                lowestIdAdjacencyList[i] = new Vector();
            }
            for(Integer node : nodes)
            {
                for (int j = 0; j < this.adjList[node].length; j++) {
                    int succ = this.adjList[node][j];
                    if (nodes.contains(new Integer(succ))) {
                        lowestIdAdjacencyList[node].add(new Integer(succ));
                    }
                }
            }
        }

        return lowestIdAdjacencyList;
    }

    private void getStrongConnectedComponents(int root) {
        this.sccCounter++;
        this.lowlink[root] = this.sccCounter;
        this.number[root] = this.sccCounter;
        this.visited[root] = true;
        this.stack.push(new Integer(root));
        this.onStack.add(root);

        for (int i = 0; i < this.adjList[root].length; i++) {
            int w = this.adjList[root][i];
            if (!this.visited[w]) {
                this.getStrongConnectedComponents(w);
                this.lowlink[root] = Math.min(lowlink[root], lowlink[w]);
            } else if (this.number[w] < this.number[root]) {
                if (onStack.contains(w)) {
                    lowlink[root] = Math.min(this.lowlink[root], this.number[w]);
                }
            }
        }

        if ((lowlink[root] == number[root]) && (stack.size() > 0)) {
            int next = -1;
            HashSet<Integer> scc = new HashSet<>();

            do {
                next  =this.stack.pop();
                onStack.remove(next);
                scc.add(next);
            } while (this.number[next] > this.number[root]);

            if (scc.size() > 1) {
                this.currentSCCs.add(scc);
            }
        }
    }
}