//???1:AC?????????
#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <cfloat>
#include <stack>
#include <queue>
#include <vector>
#include <string>
#include <iostream>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;

struct Info{
	Info(int arg_town,int arg_total_cost){
		town = arg_town;
		total_cost = arg_total_cost;
	}
	bool operator<(const struct Info &arg) const{
		return total_cost > arg.total_cost;
	};
	int town,total_cost;
};

struct Data{
	Data(int arg_town,ll arg_total_cost){
		town = arg_town;
		total_cost = arg_total_cost;
	}
	bool operator<(const struct Data &arg) const{
		return total_cost > arg.total_cost;
	};
	int town;
	ll total_cost;
};


int main(){

	int N,M,K,S;
	scanf("%d %d %d %d",&N,&M,&K,&S);

	bool* is_zombie = new bool[N+1];
	bool* is_danger_town = new bool[N+1];

	for(int i = 1; i <= N; i++){
		is_zombie[i] = false;
		is_danger_town[i] = false;
	}

	int low,high;
	scanf("%d %d",&low,&high);

	vector<int> Zombie;

	int tmp;
	for(int loop = 0; loop < K; loop++){
		scanf("%d",&tmp);
		is_zombie[tmp] = true;
		Zombie.push_back(tmp);
	}

	vector<int> V[N+1];

	int from,to;
	for(int loop = 0; loop < M; loop++){
		scanf("%d %d",&from,&to);
		V[from].push_back(to);
		V[to].push_back(from);
	}

	if(S > 0){
		int* min_dist = new int[N+1];
		for(int i = 1; i <= N; i++){
			min_dist[i] = BIG_NUM;
		}

		priority_queue<Info> Q;

		for(int i = 0; i < Zombie.size(); i++){
			min_dist[Zombie[i]] = 0;
			for(int k = 0; k < V[Zombie[i]].size(); k++){
				if(min_dist[V[Zombie[i]][k]] > 1){
					min_dist[V[Zombie[i]][k]] = 1;
					Q.push(Info(V[Zombie[i]][k],1));
				}
			}
		}

		while(!Q.empty()){

			if(Q.top().total_cost == S){
				Q.pop();
			}else if(Q.top().total_cost > min_dist[Q.top().town]){
				Q.pop();
			}else{

				for(int i = 0; i < V[Q.top().town].size(); i++){
					if(min_dist[V[Q.top().town][i]] > Q.top().total_cost+1){
						min_dist[V[Q.top().town][i]] = Q.top().total_cost+1;
						Q.push(Info(V[Q.top().town][i],Q.top().total_cost+1));
					}
				}
				Q.pop();
			}
		}

		for(int i = 1; i <= N; i++){
			if(min_dist[i] <= S){
				is_danger_town[i] = true;
			}
		}
	}

	ll* min_cost = new ll[N+1];
	min_cost[1] = 0;

	for(int i = 2; i <= N; i++){
		min_cost[i] = 999999999999999;
	}

	priority_queue<Data> PQ;

	for(int i = 0; i < V[1].size(); i++){
		if(is_zombie[V[1][i]])continue;

		if(is_danger_town[V[1][i]]){
			min_cost[V[1][i]] = high;
		}else{
			min_cost[V[1][i]] = low;
		}
		PQ.push(Data(V[1][i],min_cost[V[1][i]]));
	}

	ll next_cost;

	while(!PQ.empty()){

		if(PQ.top().town == N){
			PQ.pop();
		}else if(PQ.top().total_cost > min_cost[PQ.top().town]){
			PQ.pop();
		}else{

			for(int i = 0; i < V[PQ.top().town].size(); i++){
				if(is_zombie[V[PQ.top().town][i]])continue;

				if(V[PQ.top().town][i] == N){
					next_cost = PQ.top().total_cost;
				}else{
					if(is_danger_town[V[PQ.top().town][i]]){
						next_cost = PQ.top().total_cost+high;
					}else{
						next_cost = PQ.top().total_cost+low;
					}
				}
				if(min_cost[V[PQ.top().town][i]] > next_cost){
					min_cost[V[PQ.top().town][i]] = next_cost;
					PQ.push(Data(V[PQ.top().town][i],next_cost));
				}
			}

			PQ.pop();
		}
	}

	printf("%lld\n",min_cost[N]);

	return 0;
}