// Slower C++ solution:
//#pragma GCC target("avx2")

//#pragma GCC optimize("O3")

   

//#include <x86intrin.h>

#include <bits/stdc++.h>   

#include <ext/pb_ds/assoc_container.hpp>

#include <ext/pb_ds/tree_policy.hpp>

 

using namespace __gnu_pbds;

using namespace std;



template<typename T> using ordered_set = tree <T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

     

#define F first

#define S second           

#define lb lower_bound               

#define ub upper_bound

#define pb push_back

#define pf push_front    

#define ppb pop_back

#define mp make_pair                                     

#define bpp __builtin_popcountll                                                                                        

#define sqr(x) ((x) * (x)) 

#define al 0x3F3F3F3F

#define sz(x) (int)x.size()

#define all(x) x.begin(), x.end()

#define in insert

#define ppf pop_front

#define endl '\n'

//#define int long long

 

typedef unsigned long long ull;

typedef long long ll;

typedef long double ld;

typedef pair <int, int> pii;

 

const int mod = (int)1e9 + 7;

const int N = (int)3e5 + 123;

const ll inf = (ll)1e18 + 1;



const double pi = acos (-1.0);

const double eps = 1e-7;                  

const int dx[] = {0, 0, 1, 0, -1};

const int dy[] = {0, 1, 0, -1, 0};



int n, m, d[N][3], s, t;

queue <int> q;

vector <int> g[N];



inline void boost () {                    

   ios_base :: sync_with_stdio (NULL);

   cin.tie (NULL), cout.tie (NULL);          

}                                                     



inline void Solve () {

   cin >> n >> m;

   for (int i = 1; i <= m; i ++) {

      int x, y;

      cin >> x >> y;

      g[x].pb (y);

   }

   for (int i = 1; i <= n; i ++)

      for (int j = 0; j < 3; j ++)

         d[i][j] = mod;

   cin >> s >> t;

   d[s][0] = 0;

   q.push (s);

   while (sz (q)) {

      int v = q.front ();

      q.pop ();

      for (int ost = 0; ost < 3; ost ++) {

         int nxt = (ost + 1) % 3;

         for (auto to : g[v]) {    

            if (d[to][nxt] > d[v][ost] + 1) {

               d[to][nxt] = d[v][ost] + 1;

               q.push (to);

            }

         }

      }

   }

   if (d[t][0] == mod) cout << -1, exit (0);

   cout << d[t][0] / 3;

}



main () {                                       

// freopen (".in", "r", stdin);    

// freopen (".out", "w", stdout);              

   boost ();

   int tt = 1;

   //cin >> tt;   

   while (tt --) {

      Solve ();

   }                                               

   return 0;      

}

                          

// Faster C++ solution for the same problem (measured speedup: 1.3717905846808836x):
#include <bits/stdc++.h>

// #include <ext/pb_ds/assoc_container.hpp>

// #include <ext/pb_ds/tree_policy.hpp>

// #define ordered_set tree<int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update>



#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

#define debug cerr <<

#define ll long long

// #define int long long

#define FOR(i, x, y) for(int i = x; i <= y; ++i)

#define pb push_back

#define eb emplace_back

#define Size(v) (int)v.size()



using namespace std;

// using namespace __gnu_pbds;



// Always

const int nax = 1e5 + 5, INF = 1e9 + 7;

int n, m, s, t, dist[nax];

bool vis[nax][4], v[nax];

vector<int> g[nax], adj[nax];



void bfs() {

	queue<int> q;

	q.push(s);

	dist[s] = 0;

	v[s] = true;

	while (!q.empty()) {

		int u = q.front(); q.pop();

		for (auto &c : adj[u]) {

			if (v[c]) continue;

			v[c] = true;

			dist[c] = dist[u] + 1;

			q.push(c);

		}

	}

}



void solve() {

	fill(dist, dist + nax, INF);

	cin >> n >> m;

	FOR (i, 1, m) {

		int u, v; cin >> u >> v;

		g[u].pb(v);

	}

	cin >> s >> t;

	queue<int> que;

	que.push(s);

	dist[s] = 0;

	vis[s][0] = true;

	while (!que.empty()) {

		int i = que.front(); que.pop();

		// cerr << "i: " << i << '\n';

		queue<pair<int, int>> q;

		q.push({i, 0});

		while (!q.empty()) {

			auto p = q.front(); q.pop();

			if (p.second == 3) {

				dist[p.first] = min(dist[p.first], dist[i] + 1);

				que.push(p.first);

				continue;

			}

			else {

				for (auto &c : g[p.first]) {

					if (vis[c][p.second + 1]) {

						// cerr << "vis " << c << ' ' << p.second + 1 << '\n';

						continue;

					}

					vis[c][p.second + 1] = true;

					q.push({c, p.second + 1});

				}

			}

		}

	}

	// FOR (i, 1, n) cout << dist[i] << ' ';

	// cout << '\n';

	if (dist[t] == INF) cout << -1;

	else cout << dist[t];

}



int32_t main() {

	ios_base::sync_with_stdio(false);

	cin.tie(0); cout.tie(0);

	int t = 1;

	while (t--) 

		solve();

	return 0;

}