#include <bits/stdc++.h>
using namespace std;
const int MAXN = 2.1e5;
namespace dsu {
int par[MAXN];
void reset(int N) {
  for (int i = 0; i < N; i++) par[i] = -1;
}
int getPar(int a) { return par[a] < 0 ? a : (par[a] = getPar(par[a])); }
void merge(int a, int b) {
  a = getPar(a), b = getPar(b);
  if (a == b) return;
  if (par[b] < par[a]) swap(a, b);
  par[a] += par[b];
  par[b] = a;
}
}  // namespace dsu
int main() {
  ios::sync_with_stdio(0), cin.tie(0);
  int N, K, R;
  cin >> N >> K >> R;
  vector<pair<int, int>> edges(N - 1);
  vector<vector<int>> adj(N);
  for (int e = 0; e < N - 1; e++) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    edges[e] = {a, b};
    adj[a].push_back(b);
    adj[b].push_back(a);
  }
  {
    vector<int> sz(N);
    function<void(int, int)> dfs_sz = [&](int cur, int prv) -> void {
      sz[cur] = 1;
      for (int nxt : adj[cur]) {
        if (nxt == prv) continue;
        dfs_sz(nxt, cur);
        sz[cur] += sz[nxt];
      }
      nth_element(adj[cur].begin(), adj[cur].begin(), adj[cur].end(),
                  [&](int i, int j) { return sz[i] > sz[j]; });
    };
    dfs_sz(0, -1);
  }
  vector<int> depth(N);
  vector<int> heavyRoot(N);
  vector<int> par(N);
  vector<int> preorder;
  preorder.reserve(N);
  vector<int> st(N);
  {
    function<void(int, int)> dfs_hld = [&](int cur, int prv) -> void {
      par[cur] = prv;
      depth[cur] = (prv == -1 ? 0 : depth[prv] + 1);
      st[cur] = int(preorder.size());
      preorder.push_back(cur);
      par[cur] = prv;
      heavyRoot[cur] =
          (prv != -1 && st[prv] + 1 == st[cur] ? heavyRoot[prv] : cur);
      for (int nxt : adj[cur]) {
        if (nxt == prv) continue;
        dfs_hld(nxt, cur);
      }
    };
    dfs_hld(0, -1);
    assert(int(preorder.size()) == N);
  }
  auto getAnc = [&](int cur, int d) -> int {
    d = depth[cur] - d;
    assert(d >= 0);
    while (d < depth[heavyRoot[cur]]) {
      cur = par[heavyRoot[cur]];
    }
    return preorder[st[cur] - (depth[cur] - d)];
  };
  auto lca = [&](int a, int b) -> int {
    while (heavyRoot[a] != heavyRoot[b]) {
      assert(min(a, b) >= 0);
      if (st[a] > st[b]) swap(a, b);
      b = par[heavyRoot[b]];
    }
    return st[a] < st[b] ? a : b;
  };
  vector<pair<int, int>> restDist(N, {-1, -1});
  {
    vector<int> q;
    q.reserve(N);
    for (int r = 0; r < R; r++) {
      int v;
      cin >> v;
      v--;
      restDist[v] = {0, v};
      q.push_back(v);
    }
    for (int z = 0; z < int(q.size()); z++) {
      int cur = q[z];
      for (int nxt : adj[cur]) {
        if (restDist[nxt].first == -1) {
          restDist[nxt] = restDist[cur];
          restDist[nxt].first++;
          q.push_back(nxt);
        }
      }
    }
  }
  dsu::reset(N);
  for (int e = 0; e < N - 1; e++) {
    int a, b;
    tie(a, b) = edges[e];
    if (restDist[a].first + restDist[b].first + 1 <= K) {
      dsu::merge(restDist[a].second, restDist[b].second);
    }
  }
  auto query = [&](int a, int b) -> bool {
    int c = lca(a, b);
    int da = depth[a] - depth[c];
    int db = depth[b] - depth[c];
    int d = da + db;
    if (d <= K) return true;
    int md = (K + 1) / 2;
    int pa = (md <= da ? getAnc(a, md) : getAnc(b, d - md));
    int pb = (md <= db ? getAnc(b, md) : getAnc(a, d - md));
    return md + max(restDist[pa].first, restDist[pb].first) <= K &&
           dsu::getPar(restDist[pa].second) == dsu::getPar(restDist[pb].second);
  };
  int Q;
  cin >> Q;
  while (Q--) {
    int a, b;
    cin >> a >> b;
    a--, b--;
    cout << (query(a, b) ? "YES" : "NO") << '\n';
  }
  return 0;
}
