using System;
using System.Collections.Generic;
using System.Linq;

class MainClass
{
    static void Main()
    {
        var NM = Console.ReadLine().Split().Select(int.Parse).ToArray();
        int N = NM[0], M = NM[1];
        var G = new Graph<(int,long)>(N);
        for (int i = 0; i < M; i++)
        {
            var r = Console.ReadLine().Split().Select(_=>int.Parse(_)-1).ToArray();
            G.Add(r[0], (r[1],1L));
        }
        var ST = Console.ReadLine().Split().Select(_=>int.Parse(_)-1).ToArray();
        int S = ST[0], T = ST[1];

        var d = Dijkstra(G, S);

        if (d[T] == long.MaxValue) Console.WriteLine(-1);
        else Console.WriteLine(d[T]/3);
    }

    static long[] Dijkstra(Graph<(int to, long cost)> G, int sp)
    {
        //sp からスタート
        var d = new long[3][];
        for (int i = 0; i < 3; i++)
        {
            d[i] = Enumerable.Repeat(long.MaxValue, G.Length).ToArray();
        }
        d[0][sp] = 0;
        var que = new PriorityQueue<(int to, long cost,int times)>(500000, (x, y) => x.cost.CompareTo(y.cost));
        que.Push((sp, 0,0));
        while (que.Size > 0)
        {
            var p = que.Pop();
            int v = p.to;
            int t = p.times;
            int nt = (t + 1) % 3;
            //if (d[t][v] < p.cost) continue;
            foreach (var i in G[v])
            {
                if (d[nt][i.to] > d[t][v] + i.cost)
                {
                    d[nt][i.to] = d[t][v] + i.cost;
                    que.Push((i.to, d[nt][i.to],nt));
                }
            }
        }
        return d[0];
    }
}
class Graph<T>
{
    private List<T>[] G;
    public Graph(int size)
    {
        G = new List<T>[size];
        for (int i = 0; i < size; i++)
        {
            G[i] = new List<T>();
        }
    }

    public List<T> this[int i] => G[i];
    public void Add(int from, T to) => G[from].Add(to);
    public List<T>[] ToListArray() => G;
    public int Length => G.Length;
}
public class PriorityQueue<T>
{
    public long Size { get; private set; } = 0;
    public long MaxSize { get; private set; } = 0;
    public T[] m_heap;
    private Comparison<T> Comp = null;

    public PriorityQueue(long maxSize, Comparison<T> comp)
    {
        if (maxSize <= 0)
            throw new Exception();
        MaxSize = maxSize;
        m_heap = new T[maxSize];

        Comp = comp;
    }

    public void Push(T x)
    {
        if (Size == MaxSize)
        {
            T[] new_heap = new T[MaxSize << 1];
            Array.Copy(m_heap, new_heap, MaxSize);
            m_heap = new_heap;
            MaxSize <<= 1;
        }

        long i = Size++;
        while (i > 0)
        {
            long p = (i - 1) / 2;
            if (Comp(m_heap[p], x) <= 0)
                break;
            m_heap[i] = m_heap[p];
            i = p;
        }
        m_heap[i] = x;
    }

    public T Pop()
    {
        if (Size == 0)
            throw new Exception("Queue is empty.");

        T result = m_heap[0];
        T x = m_heap[--Size];
        long i = 0;
        while (i * 2 + 1 < Size)
        {
            long c1 = i * 2 + 1, c2 = i * 2 + 2;
            if (c2 < Size && Comp(m_heap[c2], m_heap[c1]) < 0)
                c1 = c2;
            if (Comp(m_heap[c1], x) >= 0)
                break;
            m_heap[i] = m_heap[c1];
            i = c1;
        }
        m_heap[i] = x;

        return result;
    }
}


Measured memory_bytes: 56480