#include <bits/stdc++.h>
#define all(dataStructure) dataStructure.begin(),dataStructure.end()
#define ll long long

using namespace std;
namespace std {
        template <typename T, int D>
        struct _vector : public vector <_vector <T, D - 1>> {
                static_assert(D >= 1, "Dimension must be positive!");
                template <typename... Args>
                _vector(int n = 0, Args... args) : vector <_vector <T, D - 1>> (n, _vector <T, D - 1> (args...)) {}
        };
        // _vector <int, 3> a(n, m, k);: int a[n][m][k].
        // _vector <int, 3> a(n, m, k, x);: int a[n][m][k] initialized with x.
        template <typename T>
        struct _vector <T, 1> : public vector <T> {
                _vector(int n = 0, const T& val = T()) : vector <T> (n, val) {}
        };
}

const int MAX = 1e5 + 3;
const ll MOD[] = {1000000007, 998244353};

int n, m, k, q;
ll dp[MAX];
ll ans[MAX], L[MAX], R[MAX];
vector <pair <int, int>> adj[MAX];
priority_queue <pair <ll, int>> pq;
int u[MAX], v[MAX];

void dijkstra() {
        while (pq.size()) {
                auto [D, u] = pq.top();
                pq.pop();
                D = -D;
                if (D != dp[u]) continue;
                for (auto &[v, c] : adj[u]) {
                        if (dp[v] > dp[u] + c) {
                                dp[v] = dp[u] + c;
                                pq.emplace(-dp[v], v);
                        }
                }
        }
}

vector <ll> disDist;
vector <pair <int, int>> edges[MAX];
vector <int> queriesAt[MAX];
int pa[MAX];

int findpa(int u) {
        return u == pa[u] ? u : pa[u] = findpa(pa[u]);
}

void join(int u, int v) {
        u = findpa(u);
        v = findpa(v);
        pa[v] = u;
}

template <typename dataType>
inline void compress(vector <dataType> &x) {
        sort(all(x));
        x.erase(unique(all(x)), x.end());
}

void init() {
        for (int u = 1; u <= n; u++) disDist.push_back(dp[u]);
        compress(disDist);

        for (int i = 0; i < q; i++) {
                L[i] = 0, R[i] = (int)disDist.size() - 1;
        }

        for (int u = 1; u <= n; u++) {
                for (auto &[v, c] : adj[u]) if (u < v) {
                        int id = lower_bound(all(disDist), min(dp[u], dp[v])) - disDist.begin();
                        edges[id].emplace_back(u, v);
                }
        }
}

void Solve() {
        cin >> n >> m >> k >> q;
        memset(dp, 0x0f, sizeof dp);

        for (int i = 0; i < m; i++) {
                int u, v, c;
                cin >> u >> v >> c;
                adj[u].emplace_back(v, c);
                adj[v].emplace_back(u, c);
        }

        for (int i = 0; i < k; i++) {
                int x;
                cin >> x;
                dp[x] = 0;
                pq.emplace(0ll, x);
        }

        dijkstra();
        init();

        for (int i = 0; i < q; i++) {
                cin >> u[i] >> v[i];
        }


        int itorateTime = 18;
        while (itorateTime--) {
                iota(pa + 1, pa + n + 1, 1);
                for (int i = 0; i < q; i++) {
                        if (L[i] <= R[i]) {
                                queriesAt[(L[i] + R[i]) / 2].push_back(i);
                        }
                }
                for (int i = (int)disDist.size() - 1; i >= 0; i--) {
                        for (auto &[u, v] : edges[i]) join(u, v);
                        for (int &j : queriesAt[i]) {
                                if (findpa(u[j]) == findpa(v[j])) {
                                        ans[j] = disDist[i];
                                        L[j] = i + 1;
                                } else {
                                        R[j] = i - 1;
                                }
                        }
                        queriesAt[i].clear();
                }
        }

        for (int i = 0; i < q; i++) cout << ans[i] << '\n';
}

int32_t main() {
        ios_base::sync_with_stdio(0);
        cin.tie(0);

        #define TASK "WALK"
        if (fopen(TASK".INP", "r")) {
                freopen(TASK".INP", "r", stdin);
                freopen(TASK".OUT", "w", stdout);
        }

        /* int TEST = 1; cin >> TEST; while (TEST--) */ Solve();

        cerr << "\nTime elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC << "s\n";
        return 0;
}