#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define len(x) int((x).size())

template <class T> struct RMQ {
  vector<vector<T>> jmp;
  RMQ(const vector<T> &V) : jmp(1, V) {
    for (int pw = 1, k = 1; pw * 2 <= len(V); pw *= 2, ++k) {
      jmp.emplace_back(len(V) - pw * 2 + 1);
      for (int j = 0; j < len(jmp[k]); j++)
        jmp[k][j] = min(jmp[k - 1][j], jmp[k - 1][j + pw]);
    }
  }
  T query(int a, int b) {
    assert(a < b); // or return inf if a == b
    int dep = 31 - __builtin_clz(b - a);
    return min(jmp[dep][a], jmp[dep][b - (1 << dep)]);
  }
};

struct LCA {
  int T = 0;
  vector<int> depth, time, path, ret;
  RMQ<int> rmq;

  LCA(vector<vector<int>> &C)
      : depth(len(C)), time(len(C)), rmq((dfs(C, 0, -1, 0), ret)) {}
  void dfs(vector<vector<int>> &C, int v, int par, int d) {
    time[v] = T++;
    depth[v] = d;
    for (int y : C[v])
      if (y != par) {
        path.push_back(v), ret.push_back(time[v]);
        dfs(C, y, v, d + 1);
      }
  }

  int lca(int a, int b) {
    if (a == b)
      return a;
    tie(a, b) = minmax(time[a], time[b]);
    return path[rmq.query(a, b)];
  }

  int dist(int a, int b) { return depth[a] + depth[b] - 2 * depth[lca(a, b)]; }
};

struct racer_t {
  int idx, p, v;
};

int main() {
  int n, m, k;
  cin >> n >> m >> k;
  vector<vector<int>> graph(n);
  for (int i = 0; i < n - 1; i++) {
    int u, v;
    cin >> u >> v;
    graph[--u].push_back(--v);
    graph[v].push_back(u);
  }

  LCA lct{graph};

  vector<vector<racer_t>> racers(n);
  for (int i = 0; i < m; i++) {
    int p, v;
    cin >> p >> v;
    racers[--p].push_back({i, p, v});
  }
  int e, c;
  cin >> e >> c;
  e--;
  vector<bool> is_special(n);
  for (int i = 0; i < c; i++) {
    int x;
    cin >> x;
    is_special[--x] = true;
  }
  vector<int> sz(n);
  function<void(int, int)> dfs1 = [&](int curr, int par) {
    sz[curr] = 1;
    for (auto neighbor : graph[curr]) {
      if (neighbor != par) {
        dfs1(neighbor, curr);
        sz[curr] += sz[neighbor];
      }
    }
  };
  dfs1(e, -1);

  function<void(int, int)> dfs2 = [&](int curr, int par) {
    int mx = -1, bigchild = -1;
    for (auto neighbor : graph[curr]) {
      if (neighbor != par && mx < sz[neighbor]) {
        mx = sz[neighbor];
        bigchild = neighbor;
      }
    }
    for (auto neighbor : graph[curr]) {
      if (neighbor != par && neighbor != bigchild) {
        dfs2(neighbor, curr);
      }
    }
    if (bigchild != -1) {
      dfs2(bigchild, curr);
      racers[curr].swap(racers[bigchild]);
      racers[curr].insert(racers[curr].end(), racers[bigchild].begin(),
                          racers[bigchild].end());
    }
    for (auto neighbor : graph[curr]) {
      if (neighbor != par && neighbor != bigchild) {
        racers[curr].insert(racers[curr].end(), racers[neighbor].begin(),
                            racers[neighbor].end());
      }
    }
    if (is_special[curr]) {
      sort(racers[curr].begin(), racers[curr].end(),
           [&](const racer_t &a, const racer_t &b) {
             auto ad = lct.dist(a.p, curr) * 1ll * a.v;
             auto bd = lct.dist(b.p, curr) * 1ll * b.v;
             if (ad != bd)
               return ad < bd;
             return a.v < b.v;
           });
      while (len(racers[curr]) > k) {
        racers[curr].pop_back();
      }
    }
  };
  dfs2(e, -1);
  vector<ll> ans(m, -1);
  for (const auto &racer : racers[e]) {
    ans[racer.idx] = lct.dist(racer.p, e) * 1ll * racer.v;
  }
  for (int i = 0; i < m; i++) {
    cout << ans[i] << '\n';
  }
}