#include <bits/stdc++.h>
using namespace std;
using ll = long long;
signed main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  int n, k, r;
  while (cin >> n >> k >> r) {
    vector<vector<int>> g(2 * n);
    for (int i = 1; i < n; ++i) {
      int x, y;
      cin >> x >> y;
      g[x].push_back(n + i);
      g[y].push_back(n + i);
      g[n + i].push_back(x);
      g[n + i].push_back(y);
    }
    queue<int> que;
    vector<int> dist(2 * n, -1);
    for (int i = 0; i < r; ++i) {
      int v;
      cin >> v;
      que.emplace(v);
      dist[v] = 0;
    }
    struct DSU {
      int n;
      vector<int> p, sz;
      DSU(int n) : n(n), p(n), sz(n, 1) { iota(p.begin(), p.end(), 0); }
      int getp(int v) {
        if (v == p[v]) return v;
        return p[v] = getp(p[v]);
      }
      bool unite(int u, int v) {
        u = getp(u);
        v = getp(v);
        if (u == v) return false;
        if (sz[u] < sz[v]) swap(u, v);
        sz[u] += sz[v];
        p[v] = u;
        return true;
      }
    };
    DSU dsu(2 * n);
    while (!que.empty()) {
      auto v = que.front();
      que.pop();
      if (dist[v] == k) {
        break;
      }
      for (auto to : g[v]) {
        if (dist[to] == -1) {
          que.emplace(to);
          dist[to] = dist[v] + 1;
        }
        dsu.unite(v, to);
      }
    }
    const int maxlog = 20;
    vector<vector<int>> parent(maxlog, vector<int>(2 * n));
    vector<int> depth(2 * n);
    function<void(int, int, int)> dfs = [&](int v, int pr, int d) {
      depth[v] = d;
      parent[0][v] = pr;
      for (int i = 1; i < maxlog; ++i) {
        parent[i][v] = parent[i - 1][parent[i - 1][v]];
      }
      for (auto to : g[v]) {
        if (to != pr) {
          dfs(to, v, d + 1);
        }
      }
    };
    dfs(1, 1, 0);
    auto lca = [&](int u, int v) {
      if (depth[u] < depth[v]) swap(u, v);
      for (int i = maxlog - 1; i >= 0; --i) {
        if (depth[parent[i][u]] >= depth[v]) {
          u = parent[i][u];
        }
      }
      if (u == v) return u;
      for (int i = maxlog - 1; i >= 0; --i) {
        if (parent[i][u] != parent[i][v]) {
          u = parent[i][u];
          v = parent[i][v];
        }
      }
      return parent[0][u];
    };
    auto up = [&](int v, int d) {
      for (int i = maxlog - 1; i >= 0; --i) {
        if (d & (1 << i)) {
          v = parent[i][v];
        }
      }
      return v;
    };
    int q;
    cin >> q;
    for (int i = 0; i < q; ++i) {
      int a, b;
      cin >> a >> b;
      int l = lca(a, b);
      int d = depth[a] + depth[b] - 2 * depth[l];
      if (d <= 2 * k) {
        cout << "YES";
      } else {
        if (depth[a] - depth[l] >= k) {
          if (depth[b] - depth[l] >= k) {
            b = up(b, k);
          } else {
            b = up(a, d - k);
          }
          a = up(a, k);
        } else {
          a = up(b, d - k);
          b = up(b, k);
        }
        int cola = dsu.getp(a);
        int colb = dsu.getp(b);
        cout << (cola == colb ? "YES" : "NO");
      }
      cout << "\n";
    }
    break;
  }
}
