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


public class Main {
    public static void main(String[] args) throws Exception {
        
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        Node[] nodes = new Node[N];
        for(int i = 0; i < N; i++){
            nodes[i] = new Node(i);
        }

        int M = sc.nextInt();
        for(int i = 0; i < M; i++){
            int u = sc.nextInt() - 1;
            int v = sc.nextInt() - 1;
            nodes[u].adjacents.add(nodes[v]);
        }
        
        int S = sc.nextInt() - 1;
        int T = sc.nextInt() - 1;
        
        int shortest = bfs(N, nodes, S, T);
        System.out.println( (shortest >= 0 ) ? shortest / 3 : -1 );
    }
    
    private static int bfs(int N, Node[] nodes, int S, int T){
        int[][] dist = new int[N][3];
        boolean[][] visited = new boolean[N][3];
        
        for(int i = 0; i < N; i++){
            for(int j = 0; j < 3; j++){
                dist[i][j] = -1;
            }
        }
        
        Queue<Pair<Node, Integer>> queue = new LinkedList<>();
        queue.add(new Pair<>(nodes[S], 0));
        dist[S][0] = 0;
        visited[S][0] = true;
        
        while(!queue.isEmpty()){
            Pair<Node, Integer> p = queue.poll();
            Node n = p.first;
            int r = p.second;
            int rn = (r + 1) % 3;
            
            for(Node a : n.adjacents){
                if(!visited[a.id][rn]){
                    dist[a.id][rn] = dist[n.id][r] + 1;
                    visited[a.id][rn] = true;
                    queue.add(new Pair<>(a, rn));
                }
            }
        }
        
        return dist[T][0];
        
    }
    
    
    private static class Node {
        private final int id;
        List<Node> adjacents = new ArrayList<>();
        
        public Node(int id){
            this.id = id;
        }
    }
    
    private static class Pair<F,S>{
        private final F first;
        private final S second;
        
        public Pair(F first, S second){
            this.first = first;
            this.second = second;
        }
        
    }
}
