#include <bits/stdc++.h>
static char _in_buf[100000], *_in_p1 = _in_buf, *_in_p2 = _in_buf;
__inline __attribute__((__always_inline__)) int read() {
  register char ch =
      (__builtin_expect(_in_p1 == _in_p2, 0) &&
               (_in_p2 = (_in_p1 = _in_buf) + fread(_in_buf, 1, 100000, stdin),
                _in_p1 == _in_p2)
           ? -1
           : *_in_p1++);
  register int x = 0;
  while (ch < 48 || ch > 57)
    ch = (__builtin_expect(_in_p1 == _in_p2, 0) &&
                  (_in_p2 =
                       (_in_p1 = _in_buf) + fread(_in_buf, 1, 100000, stdin),
                   _in_p1 == _in_p2)
              ? -1
              : *_in_p1++);
  while (ch > 47 && ch < 58)
    x = (x << 3) + (x << 1) + (ch ^ 48),
    ch = (__builtin_expect(_in_p1 == _in_p2, 0) &&
                  (_in_p2 =
                       (_in_p1 = _in_buf) + fread(_in_buf, 1, 100000, stdin),
                   _in_p1 == _in_p2)
              ? -1
              : *_in_p1++);
  return x;
}
int n, k, r, q;
int dist[400005];
int que[400005], qh, qe;
struct E {
  int to, nxt;
} e[400005 << 1];
int head[400005], tot_edge;
__inline __attribute__((__always_inline__)) void add_edge(int u, int v) {
  e[++tot_edge] = (struct E){v, head[u]};
  head[u] = tot_edge;
}
int fa[400005];
int fnd(int u) {
  if (fa[u] == u) return u;
  fa[u] = fnd(fa[u]);
  return fa[u];
}
__inline __attribute__((__always_inline__)) void ufs_union(int u, int v) {
  u = fnd(u), v = fnd(v);
  if (u == v) return;
  (rand() & 1) ? (fa[u] = v) : (fa[v] = u);
}
int par[400005][20], dep[400005];
void dfs(int u, int parent, int depth) {
  dep[u] = depth;
  par[u][0] = parent;
  for (int i = head[u]; i; i = e[i].nxt) {
    int v = e[i].to;
    if (v == parent) continue;
    dfs(v, u, depth + 1);
  }
}
__inline __attribute__((__always_inline__)) int get_lca(int u, int v) {
  if (dep[u] > dep[v]) {
    int tmp = u;
    u = v, v = tmp;
  }
  register int i;
  for (i = 19; i >= 0; --i)
    if ((dep[v] - dep[u]) >> i & 1) v = par[v][i];
  if (u == v) return u;
  for (i = 19; i >= 0; --i)
    if (par[u][i] != par[v][i]) {
      u = par[u][i];
      v = par[v][i];
    }
  return par[u][0];
}
__inline __attribute__((__always_inline__)) int get_ancestor(int u, int p) {
  for (int i = 0; i < 20; ++i)
    if (p & (1 << i)) u = par[u][i];
  return u;
}
int main() {
  srand(time(NULL));
  register int i, j;
  n = read(), k = read(), r = read();
  for (i = 1; i < n; ++i) {
    int u = read(), v = read();
    add_edge(u, i + n);
    add_edge(i + n, u);
    add_edge(v, i + n);
    add_edge(i + n, v);
  }
  qh = qe = 0;
  memset(dist, -1, sizeof(dist));
  for (i = 1; i <= 2 * n; ++i) fa[i] = i;
  for (i = 0; i < r; ++i) {
    dist[j = read()] = 0;
    que[qe++] = j;
  }
  while (qh < qe) {
    int u = que[qh++];
    for (i = head[u]; i; i = e[i].nxt) {
      int v = e[i].to;
      ufs_union(u, v);
      if (dist[v] == -1) {
        dist[v] = dist[u] + 1;
        if (dist[v] < k) {
          que[qe++] = v;
        }
      }
    }
  }
  dfs(1, 0, 1);
  for (j = 1; j < 20; ++j)
    for (i = 1; i <= 2 * n; ++i) par[i][j] = par[par[i][j - 1]][j - 1];
  q = read();
  while (q--) {
    int u = read(), v = read();
    int lca = get_lca(u, v);
    int d = dep[u] + dep[v] - 2 * dep[lca];
    if (d <= 2 * k) {
      puts("YES");
      continue;
    }
    int uu, vv;
    if (dep[u] - dep[lca] >= k)
      uu = get_ancestor(u, k);
    else
      uu = get_ancestor(v, d - k);
    if (dep[v] - dep[lca] >= k)
      vv = get_ancestor(v, k);
    else
      vv = get_ancestor(u, d - k);
    puts(fnd(uu) == fnd(vv) ? "YES" : "NO");
  }
  return 0;
}
