#include <bits/stdc++.h>
using namespace std;
double PI = 3.141592653589793238462643383279;
const double EPS = 1e-9;
const long long MOD = 1000000007;
const int inf = 1 << 30;
const long long linf = 1LL << 60;
struct UF {
  vector<int> par, rank, si;
  void init(int n) {
    par.assign(n, 0);
    rank.assign(n, 0);
    si.assign(n, 1);
    iota(par.begin(), par.end(), 0);
  }
  int find(int x) {
    if (par[x] == x)
      return x;
    else
      return par[x] = find(par[x]);
  }
  void unite(int x, int y) {
    x = find(x);
    y = find(y);
    if (x == y) return;
    if (rank[x] < rank[y]) {
      par[x] = y;
      si[y] += si[x];
    } else {
      par[y] = x;
      if (rank[x] == rank[y]) rank[x]++;
      si[x] += si[y];
    }
  }
  bool same(int x, int y) { return find(x) == find(y); }
};
namespace LCA {
vector<vector<int>> G;
int root;
const int MAX_LOG_N = 20;
const int MAX_N = 400000;
int parent[MAX_LOG_N][MAX_N];
int depth[MAX_N];
void dfs(int v, int p, int d) {
  parent[0][v] = p;
  depth[v] = d;
  for (int i = 0; i < (int)G[v].size(); i++) {
    if (G[v][i] != p) dfs(G[v][i], v, d + 1);
  }
}
void init(int V, vector<vector<int>> _G) {
  G = _G;
  dfs(root, -1, 0);
  for (int k = 0; k + 1 < MAX_LOG_N; k++) {
    for (int v = 0; v < V; v++) {
      if (parent[k][v] < 0)
        parent[k + 1][v] = -1;
      else
        parent[k + 1][v] = parent[k][parent[k][v]];
    }
  }
}
int get_kth_parent(int v, int k) {
  for (int i = MAX_LOG_N - 1; i >= 0; i--) {
    if ((1 << i) > k) continue;
    v = parent[i][v];
    k -= (1 << i);
  }
  return v;
}
int lca(int u, int v) {
  if (depth[u] > depth[v]) swap(u, v);
  for (int k = 0; k < MAX_LOG_N; k++) {
    if ((depth[v] - depth[u]) >> k & 1) {
      v = parent[k][v];
    }
  }
  if (u == v) return u;
  for (int k = MAX_LOG_N - 1; k >= 0; k--) {
    if (parent[k][u] != parent[k][v]) {
      u = parent[k][u];
      v = parent[k][v];
    }
  }
  return parent[0][u];
}
}  // namespace LCA
int n, k, r;
vector<vector<int>> edge;
int g[400000];
int dis[400000];
UF uf;
int main() {
  scanf("%d%d%d", &n, &k, &r);
  edge.resize(2 * n, vector<int>());
  for (int i = 0; i < (int)n - 1; i++) {
    int u, v;
    scanf("%d%d", &u, &v);
    u--;
    v--;
    edge[u].push_back(n + i);
    edge[n + i].push_back(u);
    edge[v].push_back(n + i);
    edge[n + i].push_back(v);
  }
  uf.init(r);
  memset(g, -1, sizeof(g));
  for (int i = 0; i < (int)n * 2; i++) dis[i] = inf;
  queue<int> que;
  for (int i = 0; i < (int)r; i++) {
    int x;
    scanf("%d", &x);
    x--;
    g[x] = i;
    dis[x] = 0;
    que.push(x);
  }
  while (!que.empty()) {
    int q = que.front();
    que.pop();
    for (int i = 0; i < (int)edge[q].size(); i++) {
      int to = edge[q][i];
      if (dis[to] != inf) {
        uf.unite(g[to], g[q]);
      } else {
        dis[to] = min(dis[to], dis[q] + 1);
        g[to] = g[q];
        if (dis[to] < k) {
          que.push(to);
        }
      }
    }
  }
  int v;
  scanf("%d", &v);
  LCA::init(2 * n, edge);
  for (int i = 0; i < (int)v; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    a--;
    b--;
    int p = LCA::lca(a, b);
    if (LCA::depth[a] + LCA::depth[b] - LCA::depth[p] * 2 <= 2 * k) {
      puts("YES");
    } else {
      int ha = LCA::depth[a] - LCA::depth[p];
      int hb = LCA::depth[b] - LCA::depth[p];
      int pa, pb;
      if (ha >= k) {
        pa = LCA::get_kth_parent(a, k);
      } else {
        pa = LCA::get_kth_parent(b, hb - (k - ha));
      }
      if (hb >= k) {
        pb = LCA::get_kth_parent(b, k);
      } else {
        pb = LCA::get_kth_parent(a, ha - (k - hb));
      }
      if (g[pa] != -1 && g[pb] != -1 && uf.same(g[pa], g[pb]))
        puts("YES");
      else
        puts("NO");
    }
  }
}
