#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    long long tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (long long)value;
    return output;
}

// 有向グラフのクラス。
// ダイクストラ、ワーシャルフロイド、最大フローに対応。
// 最大フローを求める問題で、costをint128_tにしたらMLEしたことがあるので、costはint64_tにしておく。
class Directed_Graph {
    public:
    struct Edge { 
        int to; int64_t cost;
    };
    typedef std::vector<std::vector<Edge>> adj_list;
    adj_list G;
    int node_num;
    Directed_Graph() {}
    Directed_Graph(const int node_num_in) {
        node_num = node_num_in;
        G.resize(node_num);
    }
    void add_edge(const int from, const int to, const long long cost) {
        Edge edge; edge.to = to; edge.cost = cost;
        G[from].push_back(edge);
    }
    void add_edge_both(const int node1, const int node2, const long long cost) {
        add_edge(node1, node2, cost);
        add_edge(node2, node1, cost);
    }

    // 点sからの最短距離の配列を返す。
    // 戻りの値としてint128_tを用い、初期値としてint64_tの最大値を用いるのは、dist[v] + edge.costの計算でのオーバーフローを防ぐため。
    // 正しい最短距離がint64_tの最大値を超えるような事態は想定していないので、最終的にdist[v] == std::numeric_limits<int64_t>::max()だった場合、vには到達できないことを意味する。
    std::vector<int128_t> Dijkstra(int s) {
        std::vector<int128_t> dist;
        dist.resize(node_num, std::numeric_limits<int64_t>::max());

        typedef std::pair<int128_t, int> Pair;
        std::priority_queue <Pair, std::vector<Pair>, std::greater<Pair>> que;
        dist[s] = 0;
        que.push(Pair(0, s));

        while (!que.empty()) {
            Pair pair = que.top(); que.pop();
            int v = pair.second;
            if (dist[v] < pair.first) { continue; }
            for (Edge edge : G[v]) {
                if (dist[v] + edge.cost < dist[edge.to]) {
                    dist[edge.to] = dist[v] + edge.cost;
                    que.push(Pair(dist[edge.to], edge.to));
                }
            }
        }
        return dist;
    }

    /*
    std::vector<std::vector<int128_t>> Dijkstra3(int s) {
        std::vector<std::vector<int128_t>> dist;
        dist.resize(3);
        for (int i = 0; i < 3; i++) {
            dist[i].resize(node_num, std::numeric_limits<int64_t>::max());
        }

        typedef std::pair<int128_t, int> Pair;
        std::priority_queue <Pair, std::vector<Pair>, std::greater<Pair>> que;
        dist[0][s] = 0;
        que.push(Pair(0, s));

        while (!que.empty()) {
            Pair pair = que.top(); que.pop();
            int v = pair.second;
            if (dist[pair.first % 3][v] < pair.first) { continue; }
            for (Edge edge : G[v]) {
                int128_t tmp = 
                if (dist[pair.first % 3][v] + edge.cost < dist[edge.to]) {
                    dist[edge.to] = dist[v] + edge.cost;
                    que.push(Pair(dist[edge.to], edge.to));
                }
            }
        }
        return dist;
    }
    */
};


const int MAX_N = 1e5 + 10;

int N, M;
int S, T;
int u[MAX_N], v[MAX_N];

Directed_Graph dg_org = Directed_Graph(MAX_N);
Directed_Graph dg3 = Directed_Graph(MAX_N);

Directed_Graph dg = Directed_Graph(MAX_N * 3);

void dfs(int i, int rest, std::unordered_set<int>& res) {
    if (rest == 0) {
        res.insert(i);
        return;
    }
    for (auto e : dg_org.G[i]) {
        dfs(e.to, rest - 1, res);
    }
}

int main(int argc, char **argv) {
    std::cin >> N >> M;

    for (int i = 1; i <= M; i++) {
        std::cin >> u[i] >> v[i];
    }

    std::cin >> S >> T;

    for (int i = 1; i <= M; i++) {
        dg.add_edge(u[i], v[i] + N, 1);
        dg.add_edge(u[i] + N, v[i] + N * 2, 1);
        dg.add_edge(u[i] + N * 2, v[i], 1);
    }

    auto ret = dg.Dijkstra(S);

    if (ret[T] == std::numeric_limits<int64_t>::max()) {
        std::cout << -1 << std::endl;
    } else {
        std::cout << ret[T] / 3 << std::endl;
    }


    /*
    for (int i = 1; i <= M; i++) {
        dg_org.add_edge(u[i], v[i], 1);
    }

    for (int i = 1; i <= N; i++) {
        std::unordered_set<int> res2, res3;
        dfs(i, 2, res2);
        for (auto j : res2) {
            for (auto e : dg_org.G[j]) {
                res3.insert(e.to);
            }
        }
        for (auto j : res3) {
            dg3.add_edge(i, j, 1);
        }
    }

    auto ret = dg3.Dijkstra(S);

    if (ret[T] == std::numeric_limits<int64_t>::max()) {
        std::cout << -1 << std::endl;
    } else {
        std::cout << ret[T] << std::endl;
    }

    */
    
    return 0;
}

Measured memory_bytes: 27000