Ken loves ken-ken-pa (Japanese version of hopscotch). Today, he will play it on a directed graph G. G consists of N vertices numbered 1 to N, and M edges. The i-th edge points from Vertex u_i to Vertex v_i.

First, Ken stands on Vertex S. He wants to reach Vertex T by repeating ken-ken-pa. In one ken-ken-pa, he does the following exactly three times: follow an edge pointing from the vertex on which he is standing.

Determine if he can reach Vertex T by repeating ken-ken-pa. If the answer is yes, find the minimum number of ken-ken-pa needed to reach Vertex T. Note that visiting Vertex T in the middle of a ken-ken-pa does not count as reaching Vertex T by repeating ken-ken-pa.

Constraints

* 2 \leq N \leq 10^5
* 0 \leq M \leq \min(10^5, N (N-1))
* 1 \leq u_i, v_i \leq N(1 \leq i \leq M)
* u_i \neq v_i (1 \leq i \leq M)
* If i \neq j, (u_i, v_i) \neq (u_j, v_j).
* 1 \leq S, T \leq N
* S \neq T

Input

Input is given from Standard Input in the following format:


N M
u_1 v_1
:
u_M v_M
S T


Output

If Ken cannot reach Vertex T from Vertex S by repeating ken-ken-pa, print -1. If he can, print the minimum number of ken-ken-pa needed to reach vertex T.

Examples

Input

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


Output

2


Input

3 3
1 2
2 3
3 1
1 2


Output

-1


Input

2 0
1 2


Output

-1


Input

6 8
1 2
2 3
3 4
4 5
5 1
1 4
1 5
4 6
1 6


Output

2
import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int m=sc.nextInt();
        newGraph g=new newGraph();
        for(int i=0;i<n;i++)
            for(int j=0;j<3;j++)
                g.add(i+1+","+j);
        for(int i=0;i<m;i++){
            int v=sc.nextInt();
            int u=sc.nextInt();
            g.add(v+",0");
            g.add(v+",1");
            g.add(v+",2");
            g.add(u+",0");
            g.add(u+",1");
            g.add(u+",2");
            g.unadd(v+",0",u+",1");
            g.unadd(v+",1",u+",2");
            g.unadd(v+",2",u+",0");
        }
        int ans=g.depth(sc.nextInt()+",0",sc.nextInt()+",0");
        System.out.println((ans==-1)?-1:ans/3);
	}
}
class newGraph {
	Map<String, ArrayList<String>> edge;
	Map<String, Integer> vertex;

	public newGraph() {
		edge = new HashMap<String, ArrayList<String>>();
		vertex = new HashMap<String, Integer>();
	}

	public void add(String a) {
		if (!edge.containsKey(a)) {
			ArrayList<String> cont = new ArrayList<>();
			edge.put(a, cont);
			vertex.put(a, 1);
		}
	}


	public void unadd(String a, String b) {
		if (edge.containsKey(a)) {
			edge.get(a).add(b);
			vertex.put(a, vertex.get(a) + 1);
		} else {
			ArrayList<String> cont = new ArrayList<>();
			cont.add(b);
			edge.put(a, cont);
			vertex.put(a, 1);
		}
		if (!edge.containsKey(b)) {
			ArrayList<String> cont = new ArrayList<>();
			edge.put(b, cont);
		}
	}

	public int depth(String a, String b) {
		if (!vertex.containsKey(a) || !vertex.containsKey(b))
			return -1;
		Map<String, Boolean> check = new HashMap<String, Boolean>();
		Queue<String> queue = new ArrayDeque<>();
		check.put(a, false);

		queue.add(a);
		queue.add("xxkiritoxx");
		int depth = 1;
		while (!check.containsKey(b) && queue.size() != 0) {
			//System.out.println(queue.get(0));

			String quevalue=queue.poll();
			if (quevalue.equals("xxkiritoxx")) {
				depth++;
				if (queue.size() != 0)
					queue.add("xxkiritoxx");
			} else {
				ArrayList<String> cont = new ArrayList<>(edge.get(quevalue));
				//System.out.println(cont);
				for (int i = 0; i < cont.size(); i++) {
					if (!check.containsKey(cont.get(i))) {
						queue.add(cont.get(i));
						check.put(cont.get(i), false);
					}
				}
			}
		}
		return check.containsKey(b) ? depth : -1;
	}

}