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.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Scanner;
import java.util.Set;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.LinkedBlockingQueue;

public class Main {

    public static class Node {
        int index;
        long step;
        public Node(int index, long step) {
            this.index = index;
            this.step = step;
        }
    }

    public static void solve(int n, long[] steps, int[] visited1, int [] visited2, int[] visited3, int s, int t, Map<Integer, Set<Integer>> graph ) {
        BlockingQueue<Node> queue = new LinkedBlockingQueue<>();
        queue.add(new Node(s, 0L));
        visited1[s] = 1;
        while (!queue.isEmpty()) {
            Node node = queue.poll();
            long step = node.step;
            int current = node.index;
           // System.out.println("current: " + current);

            Set<Integer> next1s = graph.getOrDefault(current, new HashSet<>());
            Set<Integer> canNext1s = new HashSet<>();
            for (Integer next1 : next1s) {
                if (visited2[next1] == 0) {
                    canNext1s.add(next1);
                    visited2[next1] = 1;
                }
            }
            Set<Integer> canNext2s = new HashSet<>();
            for (Integer next2 : canNext1s) {
                Set<Integer> next3s = graph.getOrDefault(next2, new HashSet<>());
                for (Integer next3 : next3s) {
                    if (visited3[next3] == 0) {
                        canNext2s.add(next3);
                        visited3[next3] = 1;
                    }
                }
            }
            for (Integer next3: canNext2s) {
                Set<Integer> next4s = graph.getOrDefault(next3, new HashSet<>());
                for (Integer next4 : next4s) {
                    if (visited1[next4] == 0) {
                        visited1[next4] = 1;
                        queue.add(new Node(next4, step + 1));
                        steps[next4] = step + 1;
                    }
                }
            }


        }


    }
    public static void main(String [] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        Map<Integer, Set<Integer>> graph = new HashMap<>();
        for (int i = 1; i <= m; ++i) {
            int u = scanner.nextInt();
            int v = scanner.nextInt();
            Set<Integer> next = graph.getOrDefault(u, new HashSet<>());
            next.add(v);
            graph.put(u, next);
        }
        int s = scanner.nextInt();
        int t = scanner.nextInt();
        int [] visited1 = new int[n + 1];
        int [] visited2 = new int[n + 1];
        int [] visited3 = new int[n + 1];
        long[] steps = new long[n + 1];
        solve(n, steps, visited1, visited2, visited3, s, t, graph);
        if (steps[t] > 0) {
            System.out.println(steps[t]);
        } else {
            System.out.println(-1);
        }
    }

}
