#include <bits/stdc++.h>

using namespace std;

const int NMAX = 205;
const int KMAX = 11;
const int INF = (1 << 30);

struct el
{
    int node, cost;
    el()
    {
        this->node = this->cost = 0;
    }
    el(int node, int cost)
    {
        this->node = node;
        this->cost = cost;
    }
    inline bool operator<(const el &other) const
    {
        return this->cost > other.cost;
    }
};

int N, M, K, Z;
vector <int> graph[NMAX];
int dp[NMAX][(1 << KMAX)];
int dist[NMAX][NMAX], d[NMAX], friends[KMAX];
bitset <NMAX> seen;

void Dijkstra(int node)
{
    seen.reset();
    priority_queue <el> pq;
    for (int i = 0;i < N;++i)
        d[i] = INF;
    d[node] = 0;
    pq.push(el(node, 0));
    while (!pq.empty())
    {
        int cnode = pq.top().node;
        pq.pop();
        if (seen[cnode] == 0)
        {
            seen[cnode] = 1;
            for (auto &i : graph[cnode])
            {
                if (d[i] > d[cnode] + 1)
                {
                    d[i] = d[cnode] + 1;
                    pq.push(el(i, d[i]));
                }
            }
        }
    }
}

int main()
{
    ifstream fin("zoomba.in");
    ofstream fout("zoomba.out");
    fin >> N >> M >> K >> Z;
    for (int i = 0;i < K;++i)
        fin >> friends[i];
    for (int i = 1;i <= M;++i)
    {
        int u, v;
        fin >> u >> v;
        graph[u].push_back(v);
        graph[v].push_back(u);
    }
    for (int i = 0;i < K;++i)
    {
        Dijkstra(friends[i]);
        for (int j = 0;j < K;++j)
            dist[i][j] = d[friends[j]];
    }
    for (int i = 0;i < K;++i, cout << "\n")
        for (int j = 0;j < K;++j, cout << " ")
    for (int i = 0;i < K;++i)
        dp[i][(1 << i)] = 0;
    for (int state = 0;state <  (1 << K);++state)
        for (int i = 0;i < K;++i)
            if ((state & (1 << i)) > 0)
                for (int j = 0;j < K;++j)
                    if ((state & (1 << j)) == 0)
                        dp[j][state ^ (1 << j)] = min(dp[j][state ^ (1 << j)], dp[i][state] + dist[i][j]);
    int answer = INF;
    Dijkstra(Z);
    for (int i = 0;i < K;++i)
        answer = min(answer, dp[i][(1 << K) - 1] + d[i]);
    if (answer == INF)
        answer = -1;
    fout << answer << "\n";
    fin.close();
    fout.close();
    return 0;
}