// Original C++ solution (slower):
#include <iostream>

#include <queue>

#include <algorithm>

using namespace std;

#define INF 1e18

#define int long long

typedef pair<int,int> P;

#define MP make_pair



  int n, m, k, s, p, q;

  int zonbi[100001];

  int dis[100001];

  int costco[100001];

  priority_queue <P, vector<P>, greater<P> > pq;

  vector <int> pairs[100001];

signed main(){



  for (int i = 0; i < 100001; i++){

    dis[i] = INF;

    costco[i] = INF;

  }



  cin >> n >> m >> k >> s >> p >> q;

  for (int i = 0; i < k; i++){

    cin >> zonbi[i];

  }

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

    int x, y;

    cin >> x >> y;

    pairs[x].push_back(y);

    pairs[y].push_back(x);

  }



  for (int i = 0; i < k; i++){

    pq.push(MP(0, zonbi[i]));

    dis[zonbi[i]] = 0;

  }

while(!pq.empty()){

      int cost, start;

      cost = pq.top().first;

      start = pq.top().second;

      pq.pop();

      if(s == cost) continue;

      for(int j = 0; j < pairs[start].size(); j++){

        if (dis[pairs[start][j]] > cost + 1){

          dis[pairs[start][j]] = cost + 1;

          pq.push(MP(cost + 1, pairs[start][j]));

        } 

      }

    }

  pq.push(MP(0, 1));

  costco[1] = 0;

  while(!pq.empty()){

    int cost, start;

    cost = pq.top().first;

    start = pq.top().second;

    pq.pop();

    for (int i = 0; i < pairs[start].size(); i++){

      int hoge;

      if (dis[pairs[start][i]] == 0){

        continue;

      }else if (dis[pairs[start][i]] == INF){

        hoge = p;

      }else{

        hoge = q;

      }

      if (pairs[start][i] == n){

          hoge = 0;

      }

      if (costco[pairs[start][i]] > cost + hoge){

        costco[pairs[start][i]] =  cost + hoge;

        pq.push(MP(cost + hoge, pairs[start][i]));

      }

    }

  }

  cout << costco[n] << endl;

  return 0;

}

// Optimized solution to the same problem (faster):
#include <iostream>

#include <cstdio>

#include <vector>

#include <queue>

#include <algorithm>

#include <string.h>

#define F first

#define S second

#define MP make_pair

#define int long long

#define INF long(1e18)

using namespace std;

typedef pair<int, int> P;

typedef pair<P, int> PP;





int n, m, k, s, pp, q, ans[100001];

int dead[100001];

vector<int> road[100001], root;

inline int in() {

	int temp;

	scanf("%ld", &temp);

	return temp;

}

void bfs(int sta)

{

	queue<P> que;

	que.push(MP(sta, 0));

	dead[sta] = -1;

	while (!que.empty())

	{

		P p = que.front();

		que.pop();

		if (p.S == s) continue;

		for (int i = 0; i < road[p.F].size(); i++)

		{

			if (!dead[road[p.F][i]] || dead[road[p.F][i]] > p.S + 1)

			{

				que.push(MP(road[p.F][i], p.S + 1));

				dead[road[p.F][i]] = p.S + 1;

			}

		}

	}

}

void dijkstra() {

	priority_queue<P> pq;

	pq.push(MP(0, 1));

	ans[1] = 0;

	while (!pq.empty())

	{

		P p = pq.top();

		pq.pop();

		for (int i = 0; i < road[p.S].size(); i++)

		{

			if (dead[road[p.S][i]] == -1) continue;

			if (!dead[road[p.S][i]] && ans[road[p.S][i]] < p.F - pp)

			{

				pq.push(MP(p.F - pp, road[p.S][i]));

				ans[road[p.S][i]] = p.F - pp;

			}

			else if (ans[road[p.S][i]] < p.F - q) {

				pq.push(MP(p.F - q, road[p.S][i]));

				ans[road[p.S][i]] = p.F - q;

			}

		}

	}

}

signed main()

{

	cin >> n >> m >> k >> s >> pp >> q;

	for (int i = 0; i < k; i++)

	{

		root.push_back(in());

	}

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

	{

		int a = in(), b = in();

		road[a].push_back(b);

		road[b].push_back(a);

	}

	for (int i = 0; i < k; i++)

	{

		bfs(root[i]);

	}

	fill(ans, ans + n + 1, -INF);

	dijkstra();

	if (!dead[n])

		cout << -ans[n] - pp << endl;

	else

		cout << -ans[n] - q << endl;

}

// Fastest known solution for this problem: