#include <bits/stdc++.h>
using namespace std;
const int INF = 1005;
const long long INFLL = 1000000000000000002ll;
const long long MOD = 1000000007;
inline long long min(long long a, long long b, long long c) {
  return min(min(a, b), c);
}
inline long long min(long long a, long long b, long long c, long long d) {
  return min(min(min(a, b), c), d);
}
inline long long max(long long a, long long b, long long c) {
  return max(max(a, b), c);
}
inline long long max(long long a, long long b, long long c, long long d) {
  return max(max(max(a, b), c), d);
}
int N, M, K, C, D;
vector<int> People, E[55];
inline pair<int, int> inv(int n) {
  int t = (n - 1) / N;
  return {n - t * N, t};
}
inline int node(int n, int t) { return t * N + n; }
struct NetworkFlowWithCost {
  struct edge {
    int a, b, cap, cost;
    edge(int p1, int p2, int p3, int p4) : a(p1), b(p2), cap(p3), cost(p4){};
  };
  const int INF = 2147483647;
  int s, t;
  vector<edge> edges;
  vector<int> best, from;
  vector<vector<int>> e;
  NetworkFlowWithCost(int sz) {
    best.resize(sz + 1);
    e.resize(sz + 1);
    from.resize(sz + 1);
  }
  void setSource(int n) { s = n; }
  void setSink(int n) { t = n; }
  void addEdge(int a, int b, int _cap, int _cost) {
    edges.push_back(edge(a, b, _cap, _cost));
    e[a].push_back(((int)edges.size()) - 1);
    edges.push_back(edge(b, a, 0, -_cost));
    e[b].push_back(((int)edges.size()) - 1);
  }
  bool dijkstra() {
    fill(best.begin(), best.end(), INF);
    priority_queue<pair<int, int>, vector<pair<int, int>>,
                   greater<pair<int, int>>>
        q;
    best[s] = 0, q.push({0, s});
    while (!q.empty()) {
      pair<int, int> p = q.top();
      q.pop();
      int n = p.second, c = p.first;
      if (best[n] < c) continue;
      if (n == t) return true;
      for (int idx : e[n]) {
        edge &ed = edges[idx];
        if (ed.cap && c + ed.cost < best[ed.b]) {
          best[ed.b] = c + ed.cost;
          from[ed.b] = idx;
          q.push({best[ed.b], ed.b});
        }
      }
    }
    return best[t] < INF;
  }
  int minCostMaxFlow() {
    int c = 0;
    while (dijkstra()) {
      int ff = INF, n = t, prev = c;
      while (n != s) {
        edge &ed = edges[from[n]];
        c += ed.cost;
        ff = min(ff, ed.cap);
        n = ed.a;
      }
      n = t;
      while (n != s) {
        edge &ed = edges[from[n]];
        edge &rev = from[n] % 2 ? edges[from[n] - 1] : edges[from[n] + 1];
        ed.cap -= ff, rev.cap += ff;
        n = ed.a;
      }
    }
    return c;
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  while (cin >> N >> M >> K >> C >> D) {
    People.clear();
    for (int i = (1); i <= (K); i++) {
      int x;
      cin >> x;
      People.push_back(x);
    }
    for (int i = (1); i <= (N); i++) E[i].clear();
    for (int i = (1); i <= (M); i++) {
      int a, b;
      cin >> a >> b;
      E[a].push_back(b), E[b].push_back(a);
    }
    int s = 0;
    int t = 105 * N + 2;
    NetworkFlowWithCost g(t + 3);
    g.setSource(s);
    g.setSink(t);
    for (int time = (1); time <= (100); time++)
      g.addEdge(node(1, time), t, INF, 0);
    for (int p : People) g.addEdge(s, node(p, 0), 1, 0);
    for (int time = (0); time <= (100); time++) {
      for (int u = (1); u <= (N); u++) {
        g.addEdge(node(u, time), node(u, time + 1), INF, C);
        for (int v : E[u])
          for (int k = (1); k <= (50); k++)
            g.addEdge(node(u, time), node(v, time + 1), 1, C + D * (2 * k - 1));
      }
    }
    cout << g.minCostMaxFlow() << "\n";
  }
}
