#include<bits/stdc++.h>

using namespace std;

#define MAXN 10010

#define MAXM 200010

struct edge

{

        int to,nxt;

} e[MAXM << ];

int i,n,m,u,v,s,t,tot;

int head[MAXN],rhead[MAXN],deg[MAXN];

bool flag[MAXN];

namespace IO

{

    template <typename T> inline void read(T &x)

    {

        int f = ; x = ;

        char c = getchar();

        for (; !isdigit(c); c = getchar())

        {

            if (c == '-') f = -f;

        }

        for (; isdigit(c); c = getchar()) x = (x << ) + (x << ) + c - '';

        x *= f;

    }

    template <typename T> inline void write(T x)

    {

        if (x < )

        {

            putchar('-');

            x = -x;

        }

        if (x > ) write(x / );

        putchar(x %  + '');

    }

    template <typename T> inline void writeln(T x)

    {

        write(x);

        puts("");

    }

} ;

inline void addedge(int u,int v)

{

        tot++;

        e[tot] = (edge){v,head[u]};

        head[u] = tot;

}

inline void addredge(int u,int v)

{

        tot++;

        e[tot] = (edge){v,rhead[u]};

        rhead[u] = tot;

}

inline void bfs1(int s)

{

        int i,u,v,l,r;

        static int q[MAXN],cnt[MAXN];

        static bool visited[MAXN];

        for (i = ; i <= n; i++) cnt[i] = ;

        q[l = r = ] = s;

        flag[s] = true;

        while (l <= r)

        {

                u = q[l];

                l++;

                for (i = rhead[u]; i; i = e[i].nxt)

                {

                        v = e[i].to;

                        if (!visited[v])

                        {

                                visited[v] = true;

                                q[++r] = v;

                        }

                        cnt[v]++;

                }

        }

        for (i = ; i <= n; i++) flag[i] = (cnt[i] == deg[i]);

}

inline int bfs2(int s)

{

        int i,u,v,l,r;

        static int q[MAXN],dist[MAXN];

        static bool visited[MAXN];

        if (!flag[s]) return -;

        for (i = ; i <= n; i++) visited[i] = false;

        q[l = r = ] = s;

        dist[s] = ;

        visited[s] = true;

        while (l <= r)

        {

                u = q[l];

                l++;

                for (i = head[u]; i; i = e[i].nxt)

                {

                        v = e[i].to;

                        if (!visited[v] && flag[v])

                        {

                                visited[v] = true;

                                dist[v] = dist[u] + ;

                                q[++r] = v;

                        }

                }

        }

        return dist[t] >  ? dist[t] : -;

}

int main()

{

        IO :: read(n); IO :: read(m);

        for (i = ; i <= m; i++)

        {

                IO :: read(u); IO :: read(v);

                addedge(u,v);

                addredge(v,u);

                deg[u]++;

        }

        IO :: read(s); IO :: read(t);

        bfs1(t);

        IO :: writeln(bfs2(s));

        return ;

}