### BUGGY CODE ###

import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7


def main(): 
    # ダイクストラ法を用いて回答する。
    N, M = LI()
    graph = []
    from collections import defaultdict
    reversed_graph_dict = defaultdict(list)
    for _ in range(M):
        u, v = LI()
        graph.append([u,v])
        reversed_graph_dict[v].append(u)
    S, T = LI()

    # 三段先のグラフを先に作っておく。
    three_steps_dict = defaultdict(list)
    for i in range(1, N+1):
        added = set()
        first_step = reversed_graph_dict[i]
        second_step = []
        for x in first_step:
            second_step += reversed_graph_dict[x]
        third_step = []
        for x in set(second_step):
            for y in reversed_graph_dict[x]:
                if (i,y) not in added:
                    three_steps_dict[i] += [(y, 1)]
                    added.add((i,y))

    N = N+1  # 頂点の数。one-origin の場合は頂点の数+1する。
    S, T = T, S  # 始点、終点の番号

    from heapq import heappop, heappush
    inf=10 ** 18
    d=[inf for i in range(N)]
    d[S]=0  # 始点のコストを 0 とする。頂点は zero origin とする。
    prev=[None]*N

    # 辺のリストを、連結リストに変換する。始点: (終点, 辺のコスト) の list
    p=three_steps_dict

    # ここからダイクストラ法の本体。「重みつき幅優先探索」って感じ。
    q=[(d[S], S)]  # heap queue。中身は (頂点のコスト, 頂点の番号)。始点をまずは格納する。
    while q:
        # print(q,d,prev)
        du, u = heappop(q)  # queue に入っている、コスト最小の頂点を取得する。
                            # この時点で u の最小値は du に確定するので、if u == T: break してもよい。
        if u==T: break
        if d[u]<du: continue  # 点 u のコストがすでに取得したコストよりも少なかったら、更新せずに次へ。
        for v,weight in p.get(u,[]):  # u から伸びる全辺について、
            alt=du+weight
            if d[v]>alt:  # u から v に行ったほうがいまの v のコストよりも低いなら、v のコストを更新して queue へ。
                d[v]=alt
                prev[v]=u  # その点までの最短経路を覚えておく（1つ前の頂点を覚えておく）。
                heappush(q, (alt,v))

    # 終点までの距離を表示する。
    print(d[T] if d[T] != inf else -1)



main()

### FIXED CODE ###

import sys
sys.setrecursionlimit(10**7)
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def LI_(): return [int(x) - 1 for x in sys.stdin.readline().split()]
def LF(): return [float(x) for x in sys.stdin.readline().split()]
def LS(): return sys.stdin.readline().split()
def II(): return int(sys.stdin.readline())
def SI(): return sys.stdin.readline().strip()
INF = 10 ** 18
MOD = 10 ** 9 + 7

def main(): 
    N, M = LI()
    graph = []
    from collections import defaultdict
    reversed_graph_dict = defaultdict(list)
    for _ in range(M):
        u, v = LI()
        graph.append([u,v])
        reversed_graph_dict[v].append(u)
    S, T = LI()

    # print(reversed_graph_dict)

    import collections
    def bfs(graph, root):
        seen, queue = set([root]), collections.deque([[root, 0],])
        first_step_seen = set([])
        second_step_seen = set([])
        while queue:
            vertex, tries = queue.popleft()
            tries += 1

            # 三段先を見に行く。
            first_step = graph[vertex]

            second_step = []
            for x in set(first_step) - first_step_seen:
                second_step += graph[x]
            first_step_seen |= set(first_step)

            third_step = []
            for x in set(second_step) - second_step_seen:
                third_step += graph[x]
            second_step_seen |= set(second_step)

            for node in set(third_step):
                if node == S:
                    print(tries)
                    return
                if node not in seen:
                    seen.add(node)
                    queue.append([node, tries])
        print(-1)
        return

    bfs(reversed_graph_dict, T)


main()