#include <algorithm>
#include <array>
#include <cstddef>
#include <cstdint>
#include <ios>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <unordered_set>
#include <vector>

using namespace std;

template <typename N = std::size_t, typename E = std::size_t> class SparseGraph
{
public:
    using NodeType = N;
    using EdgeType = E;
    using NeighborListType = std::unordered_set<std::size_t>;

    SparseGraph(bool undirected = true) noexcept
        : undirected_(undirected)
    {
    }

    void push_node(NodeType n) noexcept
    {
        nodes_.push_back(n);
        neighbor_list_.emplace_back();
    }

    void connect(const std::size_t from, const std::size_t to, const EdgeType edge = EdgeType()) noexcept
    {
        if (undirected_)
        {
            neighbor_list_[from].insert(to);
            neighbor_list_[to].insert(from);
            edges_[std::make_pair(std::min(from, to), std::max(from, to))] = edge;
        }
        else
        {
            neighbor_list_[from].insert(to);
            edges_[std::make_pair(from, to)] = edge;
        }
    }

    void disconnect(const std::size_t from, const std::size_t to) noexcept
    {
        if (undirected_)
        {
            neighbor_list_[from].erase(to);
            neighbor_list_[to].erase(from);
            edges_.erase(std::make_pair(std::min(from, to), std::max(from, to)));
        }
        else
        {
            neighbor_list_[from].erase(to);
            edges_.erase(std::make_pair(from, to));
        }
    }

    const NodeType& node(const std::size_t index) const noexcept { return nodes_.at(index); }

    const EdgeType& edge(const std::size_t from, const std::size_t to) const noexcept
    {
        if (undirected_)
        {
            auto key = std::make_pair(std::min(from, to), std::max(from, to));
            return edges_.at(key);
        }
        else
        {
            auto key = std::make_pair(from, to);
            return edges_.at(key);
        }
    }

    EdgeType& edge(const std::size_t from, const std::size_t to) noexcept
    {
        if (undirected_)
        {
            auto key = std::make_pair(std::min(from, to), std::max(from, to));
            return edges_.at(key);
        }
        else
        {
            auto key = std::make_pair(from, to);
            return edges_.at(key);
        }
    }

    const NeighborListType& neighbor(const std::size_t index) const noexcept { return neighbor_list_[index]; }

    std::size_t size() const noexcept { return neighbor_list_.size(); }

private:
    using EdgeMap = std::map<std::pair<std::size_t, std::size_t>, EdgeType>;

    std::vector<NeighborListType> neighbor_list_;

    EdgeMap edges_;

    std::vector<NodeType> nodes_;

    bool undirected_;
};

int bfs(SparseGraph<>& graph, int start, int end)
{
    vector<bool> visited(graph.size(), false);
    queue<pair<int, int>> que;
    que.emplace(start, 0);
    visited[start] = true;

    while (!que.empty())
    {
        int node, depth;
        tie(node, depth) = que.front();
        visited[node] = true;
        que.pop();

        if (node == end)
        {
            return depth / 3;
        }

        for (auto next : graph.neighbor(node))
        {
            if (!visited[next])
            {
                visited[next] = true;
                que.emplace(next, depth + 1);
            }
        }
    }
    return -1;
}

int main()
{
    ios::sync_with_stdio(false);

    int n, m;
    cin >> n >> m;
    vector<pair<int, int>> vs(m);
    for (int i = 0; i < m; i++)
    {
        cin >> vs[i].first >> vs[i].second;
        vs[i].first--;
        vs[i].second--;
    }
    int s, t;
    cin >> s >> t;
    s--;
    t--;

    SparseGraph<> graph(false);
    for (int i = 0; i <= n * 3; i++)
    {
        graph.push_node(false);
    }

    for (int i = 0; i < 3; i++)
    {
        for (auto ft : vs)
        {
            int from, to;
            tie(from, to) = ft;
            graph.connect(n * i + from, n * ((i + 1) % 3) + to);
        }
    }

    cout << bfs(graph, s, t) << endl;
}

Measured memory_bytes: 60196