#include <bits/stdc++.h>

using namespace std;
using ll = long long;

const int MAXN = 3001;
const int MAXB = 151;
const ll INF = 1e14;

vector<int> g[MAXN];
ll bdist[MAXB][MAXB], dist[MAXN][MAXN];
int n, m, k;

void bfs(int st) {
    fill(dist[st], dist[st]+MAXN, INF);
    queue<int> q;
    q.push(st);
    dist[st][st] = 0;
    while (!q.empty()) {
        int u = q.front(); q.pop();
        for (int v : g[u]) {
            if (dist[st][v] > dist[st][u] + 1) {
                dist[st][v] = dist[st][u] + 1;
                q.push(v);
            }
        }
    }
}

void solve() {
    cin >> n >> m >> k;
    
    for (int i = 0; i < m; i++) {
        int a, b; cin >> a >> b;
        g[a].emplace_back(b);
        g[b].emplace_back(a);
    }

    int l; cin >> l;
    vector<int> terv(l+1);
    for (int i = 1; i <= l; i++) cin >> terv[i];
    int b; cin >> b;
    vector<int> ben(b+1);
    for (int i = 1; i <= b; i++) cin >> ben[i];

    for (int i = 1; i <= n; i++) {
        bfs(i);
    }

    for (int i = 1; i <= b; i++) {
        for (int j = 1; j <= b; j++) {
            bdist[i][j] = INF;
        }
        bdist[i][i] = 0;
    }

    for (int i = 1; i <= b; i++) {
        for (int j = 1; j <= b; j++) {
            int u = ben[i];
            int v = ben[j];

            if (dist[u][v] <= k) {
                bdist[i][j] = min(bdist[i][j], dist[u][v]);
            }
        }
    }

    for (int c = 1; c <= b; c++) {
        for (int i = 1; i <= b; i++) {
            for (int j = 1; j <= b; j++) {
                bdist[i][j] = min(bdist[i][j], bdist[i][c] + bdist[c][j]);
            }
        }
    }

    vector<ll> dp_last(k+1);
    for (int a = 2; a <= l; a++) {
        vector<ll> dp_curr(k+1, INF);

        int start = terv[a-1];
        int goal = terv[a];

        for (int i = 1; i <= b; i++) {
            for (int j = 1; j <= b; j++) {
                ll d = dist[start][ben[i]] + bdist[i][j] + dist[ben[j]][goal];
                ll need = dist[start][ben[i]];
                ll left = k - dist[ben[j]][goal];

                
                if (need > k) continue;
                if (left < 0) continue;

                d += dp_last[need];
                dp_curr[left] = min(dp_curr[left], d);
            }
        }

        for (int i = 0; i <= k - dist[start][goal]; i++) {
            dp_curr[i] = min(dp_curr[i], dist[start][goal] + dp_last[i + dist[start][goal]]);
        }

        for (int i = k-1; i >= 0; i--) {
            dp_curr[i] = min(dp_curr[i], dp_curr[i+1]);
        }

        dp_last = dp_curr;
    }

    ll ans = *min_element(dp_last.begin(), dp_last.end());
    cout << (ans >= INF ? -1 : ans) << "\n";
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    int t = 1; 
    // cin >> t;
    while (t--) solve();
    return 0;
}