#include <bits/stdc++.h>
using namespace std;
string to_string(string s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto& x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}
template <typename T>
void dout(string name, int idx, T arg) {
  cerr << name << " = " << to_string(arg);
}
template <typename T1, typename... T2>
void dout(string names, int idx, T1 arg, T2... args) {
  cerr << names.substr(0, names.find(',')) << " = " << to_string(arg) << ", ";
  dout(names.substr(names.find(',') + 2), idx + 1, args...);
}
class DSU {
 public:
  vector<int> p;
  int n;
  DSU(int _n) : n(_n) {
    p.resize(n);
    iota(p.begin(), p.end(), 0);
  }
  inline int get(int x) { return (x == p[x] ? x : (p[x] = get(p[x]))); }
  inline bool unite(int x, int y) {
    x = get(x);
    y = get(y);
    if (x != y) {
      p[x] = y;
      return true;
    }
    return false;
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(0);
  int n, k, r;
  cin >> n >> k >> r;
  vector<vector<int>> g(2 * n);
  int nxt = n;
  for (int i = 0; i < n - 1; i++) {
    int x, y;
    cin >> x >> y;
    --x;
    --y;
    g[x].push_back(nxt);
    g[nxt].push_back(x);
    g[y].push_back(nxt);
    g[nxt].push_back(y);
    ++nxt;
  }
  vector<int> d(2 * n, -1);
  queue<int> que;
  for (int i = 0; i < r; i++) {
    int x;
    cin >> x;
    --x;
    d[x] = 0;
    que.push(x);
  }
  DSU dsu(2 * n);
  while (!que.empty()) {
    int v = que.front();
    que.pop();
    if (d[v] == k) {
      continue;
    }
    for (int u : g[v]) {
      dsu.unite(v, u);
      if (d[u] == -1) {
        d[u] = d[v] + 1;
        que.push(u);
      }
    }
  }
  42;
  int log = 0;
  while ((1 << log) <= 2 * n) {
    ++log;
  }
  vector<vector<int>> parent(2 * n, vector<int>(log + 1, -1));
  vector<int> depth(2 * n);
  function<void(int, int)> DFS = [&](int v, int pv) {
    for (int u : g[v]) {
      if (u == pv) {
        continue;
      }
      parent[u][0] = v;
      depth[u] = depth[v] + 1;
      DFS(u, v);
    }
  };
  DFS(0, -1);
  for (int j = 1; j <= log; j++) {
    for (int i = 0; i < n; i++) {
      if (parent[i][j - 1] != -1) {
        parent[i][j] = parent[parent[i][j - 1]][j - 1];
      }
    }
  }
  auto LCA = [&](int u, int v) {
    if (u == v) {
      return u;
    }
    if (depth[u] < depth[v]) {
      swap(u, v);
    }
    for (int i = log; i >= 0; i--) {
      if (parent[u][i] != -1 && depth[parent[u][i]] >= depth[v]) {
        u = parent[u][i];
      }
    }
    if (u == v) {
      return u;
    }
    assert(depth[u] == depth[v]);
    for (int i = log; i >= 0; i--) {
      if (parent[u][i] != -1) {
        assert(parent[v][i] != -1);
        if (parent[u][i] != parent[v][i]) {
          u = parent[u][i];
          v = parent[v][i];
        }
      }
    }
    assert(parent[u][0] == parent[v][0]);
    return parent[u][0];
  };
  auto Walk = [&](int u, int v, int k) {
    int lca = LCA(u, v);
    if (k <= depth[u] - depth[lca]) {
      for (int bit = 30; bit >= 0; bit--) {
        if (k & (1 << bit)) {
          assert(parent[u][bit] != -1);
          u = parent[u][bit];
        }
      }
      return u;
    }
    int extra = k - (depth[u] - depth[lca]);
    assert(depth[v] - depth[lca] > k);
    int z = (depth[v] - depth[lca]) - extra;
    assert(z >= 0);
    for (int bit = 30; bit >= 0; bit--) {
      if (z & (1 << bit)) {
        assert(parent[v][bit] != -1);
        v = parent[v][bit];
      }
    }
    return v;
  };
  int q;
  cin >> q;
  while (q--) {
    int u, v;
    cin >> u >> v;
    --u;
    --v;
    int lca = LCA(u, v);
    42;
    int total_dist = depth[u] - depth[lca] + depth[v] - depth[lca];
    if (total_dist <= 2 * k) {
      cout << "YES" << '\n';
    } else {
      if (dsu.get(Walk(u, v, k)) == dsu.get(Walk(v, u, k))) {
        cout << "YES" << '\n';
      } else {
        cout << "NO" << '\n';
      }
    }
  }
  return 0;
}
