#include <cstdio>
#include <vector>
#include <queue>

#define MAXN 100006

using namespace std;

int n,m,s,t,f,w[MAXN],ncirc;

vector <int> circles[MAXN];

struct edge
{
    int to,circle;
};

vector <edge> a[MAXN];

struct parent
{
    int p,rib;
};

parent par[MAXN];
int used[MAXN],oused[MAXN];

void find_circles(int curr)
{
    
    int i;
    used[curr] = 1;
    oused[curr] = 1;
        
        for ( i=0; i<a[curr].size(); i++ )
        {
            int neigh = a[curr][i].to;
            
            if ( par[curr].p == neigh ) continue;
                
            if ( !used[ neigh ] )
            {
                used[neigh] = 1; 
                par[neigh].p = curr;
                par[neigh].rib = i;
                find_circles(neigh);
            }
            else if ( oused[neigh] )
            {
                ncirc++;
                int x = curr,y = i;
                
                while ( x != neigh )
                {
                    a[x][y].circle = ncirc;
                    circles[ncirc].push_back(x);
                    y = par[x].rib;
                    x = par[x].p;
                }
                a[x][y].circle = ncirc;
                circles[ncirc].push_back(x);
            }
        }
    oused[curr] = 0;
}

int levels[MAXN],parent[MAXN],firsts[MAXN],q[MAXN];

void bfs()
{
    int curr,i,read=1,write=2;
    q[read] = s;
    oused[s] = 1;
    levels[s] = 0;
    while ( read < write )
    {
        curr = q[read];
        read++;
        for ( i=0; i<a[curr].size(); i++ )
        {
            int neigh = a[curr][i].to;
            if ( !oused[neigh] )
            {
                if ( curr == s ) firsts[neigh] = neigh;
                else firsts[neigh] = firsts[curr];
                
                parent[neigh] = curr;
                oused[neigh] = 1;
                levels[neigh] = levels[curr] + 1;
                q[write] = neigh;
                write++;
            }
        }
    }
}

int path[MAXN],train[MAXN],mycircle[MAXN],distExit[MAXN];

int findStart(int circ)
{
    for ( int i=0; i<circles[circ].size(); i++ )
        if ( s == circles[circ][i] ) return i;
}

int dp[MAXN];

void d_p()
{
    for ( int i=n; i>=1; i-- )
    {
        int par,curr = q[i];
        int j;
        par = parent[curr];
        for ( j=0; j<a[par].size(); j++ )
            if ( a[par][j].to == curr )
                if ( a[par][j].circle != -1 && circles[ a[par][j].circle ].size() > t )
                    dp[curr] = circles[ a[par][j].circle ].size();
        
        for ( j=0; j<a[curr].size(); j++ )
        {
            if ( dp[ a[curr][j].to ] && dp[ a[curr][j].to ] + 2 < dp[curr] ) dp[curr] = dp[ a[curr][j].to ] + 2;
            if ( a[curr][j].to == par && a[curr][j].circle != -1 && circles[ a[curr][j].circle ].size() > t )
                dp[curr] = circles[ a[curr][j].circle ].size(); 
        }
    }
}

int main()
{
    int x,y,i,j;
    scanf ("%d%d%d%d%d",&n,&m,&s,&t,&f);
    for ( i=1; i<=m; i++ )
    {
        scanf ("%d%d",&x,&y);
        
        edge l;
        l.circle = -1;
        l.to = x;
        a[y].push_back(l);
        l.to = y;
        a[x].push_back(l);
    }
    
    train[s] = 1;
    for ( i=1; i<=t; i++ ) 
    { scanf ("%d",&w[i]); train[ w[i] ] =1; } 
    
    find_circles(1);
    
/*    for ( i=1; i<=ncirc; i++ )
    {
        for ( j=0; j<circles[i].size(); j++ ) printf ("%d ",circles[i][j]);
        printf ("\n");
    }*/
    
    bfs();
    
    int fir = w[1],circle = -1;
    for ( i=0; i<a[fir].size(); i++ )
        if ( a[fir][i].to == s && a[fir][i].circle != -1 ) circle = a[fir][i].circle;
    
    for ( i=0; i<a[s].size(); i++ )
        if ( a[s][i].to == fir && a[s][i].circle != -1 ) circle = a[s][i].circle;
   
    if ( circle != -1 )
    {
        for ( i=0; i<circles[circle].size(); i++ ) mycircle[ circles[circle][i] ] = 1;
    }
    
    path[1] = f;
    path[0] = 1;
    int c = f,exit,flag = 1;
    while ( c != s )
    {
        if ( mycircle[c] && flag )
        {
            exit = c;
            flag = 0;
        }
        c = parent[c];
        path[0]++;
        path[ path[0] ] = c;
    } 
    if ( flag ) exit = s;
    
    if ( circle == -1 )
    {
        if ( path[ path[0] - 1 ] == fir ) printf ("NO\n");
        else printf ("%d\n",levels[f]);
    }
    else
    {
        distExit[ s ] = levels[exit];
        if ( firsts[ exit ] == fir ) distExit[s] = circles[circle].size() - distExit[s];
        
        int curr_ind,ind = findStart(circle),next = ind + 1;
        if ( next == circles[circle].size() ) next = 0;
        
        int step;
       
        if ( circles[circle][next] == fir ) step = -1;
        else step = 1;
        
        curr_ind = ind;
        next = curr_ind;
        curr_ind += step;
        if ( curr_ind == circles[circle].size() ) curr_ind = 0;
        if ( curr_ind == -1 ) curr_ind = circles[circle].size()-1;
        
        distExit[exit] = 0;
        while ( circles[circle][curr_ind] != exit )
        {
            distExit[ circles[circle][curr_ind] ] = distExit[ circles[circle][next] ] - 1;
            next = curr_ind;
            curr_ind += step;
            if ( curr_ind == circles[circle].size() ) curr_ind = 0;
            if ( curr_ind == -1 ) curr_ind = circles[circle].size()-1;
        }
        
        step *= (-1);
        
        curr_ind = ind;
        next = curr_ind;
        curr_ind += step;
        if ( curr_ind == circles[circle].size() ) curr_ind = 0;
        if ( curr_ind == -1 ) curr_ind = circles[circle].size()-1;
        
        while ( circles[circle][curr_ind] != exit )
        {
            distExit[ circles[circle][curr_ind] ] = distExit[ circles[circle][next] ] + 1;
            next = curr_ind;
            curr_ind += step;
            if ( curr_ind == circles[circle].size() ) curr_ind = 0;
            if ( curr_ind == -1 ) curr_ind = circles[circle].size()-1;
        }
        
//        for ( i=0; i<circles[circle].size(); i++ ) printf ("%d %d\n",circles[circle][i],distExit[ circles[circle][i] ]);
        
        if ( t < circles[circle].size() )
        {
            if ( path[ path[0] - 1 ] == fir )
            {
                printf ("%d\n",levels[f] + 2 * distExit[f] - circles[circle].size() );
            }
            else printf ("%d\n",levels[f]);
        } 
        else
        {
            d_p();
            printf ("%d\n",levels[f]);
        }
    }
}