Problem: Given is a directed graph G with N vertices and M edges.
The vertices are numbered 1 to N, and the i-th edge is directed from Vertex A_i to Vertex B_i.
It is guaranteed that the graph contains no self-loops or multiple edges.

Determine whether there exists an induced subgraph (see Notes) of G such that the in-degree and out-degree of every vertex are both 1. If the answer is yes, show one such subgraph.
Here the null graph is not considered as a subgraph.

Constraints

* 1 \leq N \leq 1000
* 0 \leq M \leq 2000
* 1 \leq A_i,B_i \leq N
* A_i \neq B_i
* All pairs (A_i, B_i) are distinct.
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N M
A_1 B_1
A_2 B_2
:
A_M B_M


Output

If there is no induced subgraph of G that satisfies the condition, print `-1`. Otherwise, print an induced subgraph of G that satisfies the condition, in the following format:


K
v_1
v_2
:
v_K


This represents the induced subgraph of G with K vertices whose vertex set is \\{v_1, v_2, \ldots, v_K\\}. (The order of v_1, v_2, \ldots, v_K does not matter.) If there are multiple subgraphs of G that satisfy the condition, printing any of them is accepted.

Examples

Input

4 5
1 2
2 3
2 4
4 1
4 3


Output

3
1
2
4


Input

4 5
1 2
2 3
2 4
1 4
4 3


Output

-1


Input

6 9
1 2
2 3
3 4
4 5
5 6
5 1
5 2
6 1
6 2


Output

4
2
3
4
5

Solution (in JAVA):

Solution:
import java.io.*;
import java.util.*;

public class Main{
    int mod = 10007;
    PrintWriter out = new PrintWriter(System.out);
    char[][] maze;
    ArrayList<Integer>[] graph;
    int[] depth = new int[2000];
    boolean[] visited;
    int[] prev;
    ArrayList<Integer> cycleList;
    int[] dr = new int[]{1,0,-1,0}, dc = new int[]{0,1,0,-1};
    static public void main(String[] args) throws Exception{
        //BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        //String[] buf = reader.readLine().split(" ")
        Main main = new Main();
//        main.solve();
        System.out.println(main.solve());
    }
    long solve(){
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(), m = sc.nextInt();
        graph = new ArrayList[n+1];
        for(int i=0;i<=n;i++) graph[i] = new ArrayList<>();
        visited = new boolean[n+1];
        prev = new int[n+1];
        for(int i=0;i<m;i++){
            int a = sc.nextInt(), b = sc.nextInt();
            graph[a].add(b);
        }
        int start = 0;
        for(int i=1;i<=n;i++){
            dfs(i,i,new boolean[n+1], new ArrayList<>());
            if(cycleList!=null&&cycleList.size()>2) break;
        }
        if(cycleList==null||cycleList.size()<=2) start = -1;
        else{
            start = cycleList.get(0);
            int len = cycleList.size();
            for(int i=0;i<len;i++){
                prev[cycleList.get(i)] = cycleList.get((i-1+len)%len);
            }
        }

        if(start<=0) return -1;
        //Then start != -1, we found a loop
        int newStart = 0;
        while((newStart=GetNewStart(start,n))!=start){
            start = newStart;
        }
        Set<Integer> ans = getLoopNode(start);
        out.println(ans.size());
        for(int w:ans){
            out.println(w);
        }
        out.flush();
        System.exit(0);

        return -1;
    }
    int bfs(int start, int n){
        // returns a start of one loop found
//        Arrays.fill(depth,0);
        Arrays.fill(prev,0);
        LinkedList<Integer> cur = new LinkedList<>(), next = new LinkedList<>();
        boolean[] inQueue = new boolean[n+1];
        inQueue[start]= true;
        int step = 0;
        cur.add(start);
        while(cur.size()>0){
            for(int now:cur){
                for(int to:graph[now]){
                    prev[to] = now;
                    if(to==start) {
                        return start;
                    }
                    if(inQueue[to]) continue;
                    inQueue[to] = true;
                    next.add(to);
                }
            }
            cur = next; next = new LinkedList<>();
        }
        return 0;
    }
    // in fact, consider from the nodes seems too slow
    int GetNewStart(int start, int n){
        Set<Integer> cycle = getLoopNode(start);
        for(int from:cycle){
            for(int to:graph[from]){
                if(!cycle.contains(to)) continue; // dont care
                if(prev[to]!=from){
                    // we found a "shorter" loop
                    prev[to]=from;
                    if(to==start) return from;
                    else return to;
                }
            }
        }
        return start;
    }
    Set<Integer> getLoopNode(int start){
        Set<Integer> ans = new HashSet<>(100);
        int cur = prev[start];
        ans.add(start);
        while(cur!=start){
            ans.add(cur);
            cur = prev[cur];
        }
        return ans;
    }
    void dfs(int cur, int start, boolean[] visit, ArrayList<Integer> list){
        if(cycleList!=null&&cycleList.size()>2) return;
        if(cur==start&&list.size()>2){
            cycleList = new ArrayList<>(list);
            return;
        }
        if(visit[cur]) return;
        visit[cur] = true;
        list.add(cur);
        for(int to:graph[cur]){
            dfs(to,start,visit,list);
        }
        list.remove(list.size()-1);
    }
}