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.ArrayList;
import java.util.LinkedList;
import java.util.Scanner;

public class Main {
    public static void main(String args[]) {
        try (Scanner in = new Scanner(System.in)) {
            int N = in.nextInt();
            int M = in.nextInt();
            int[] u = new int[M];
            int[] v = new int[M];
            ArrayList<Integer>[] v2 = new ArrayList[N];
            for (int i = 0; i < v2.length; i++) {
                v2[i] = new ArrayList<Integer>();
            }
            for (int i = 0; i < M; i++) {
                u[i] = in.nextInt() - 1;
                v[i] = in.nextInt() - 1;
                v2[u[i]].add(v[i]);
            }
            int S = in.nextInt() - 1;
            int T = in.nextInt() - 1;

//            ArrayList<Integer>[] v3 = new ArrayList[N];
//            for (int i = 0; i < v3.length; i++) {
//                v3[i] = new ArrayList<Integer>();
//            }
//            for (int i = 0; i < N; i++) {
//                for (Integer vertex : v2[i]) {
//                    for (Integer vertex2 : v2[vertex]) {
//                        for (Integer vertex3 : v2[vertex2]) {
//                            if (!v3[i].contains(vertex3)) {
//                                v3[i].add(vertex3);
//                            }
//                        }
//                    }
//                }
//            }

            LinkedList<Integer> queue = new LinkedList<>();
            boolean[][] used = new boolean[3][N];
            {
                queue.add(S);
                queue.add(0);
                used[0][S] = true;
            }
            for (; !queue.isEmpty();) {
                int n = queue.pollFirst().intValue();
                int dist = queue.pollFirst().intValue();
                if (dist % 3 == 0 && n == T) {
                    System.out.println(dist / 3);
                    return;
                }
                for (Integer vertex : v2[n]) {
                    if (used[(dist + 1) % 3][vertex.intValue()]) {
                        continue;
                    }
                    used[(dist + 1) % 3][vertex.intValue()] = true;
                    queue.add(vertex.intValue());
                    queue.add(dist + 1);
                }
            }
            System.out.println(-1);
        }
    }

}
