#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Pii = pair<int, int>;
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
void run();
int main() {
  cin.sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(18);
  run();
  return 0;
}
struct LCA {
  vector<Vi> jumps;
  Vi level, pre, post;
  int cnt{0}, depth;
  LCA() {}
  LCA(vector<Vi>& G, int root)
      : jumps(int((G).size())),
        level(int((G).size())),
        pre(int((G).size())),
        post(int((G).size())) {
    dfs(G, root, root);
    depth = int(log2(int((G).size()))) + 2;
    for (int j = (0); j < (depth); j++)
      for (auto& v : (jumps)) v.push_back(jumps[v[j]][j]);
  }
  void dfs(vector<Vi>& G, int v, int p) {
    level[v] = p == v ? 0 : level[p] + 1;
    jumps[v].push_back(p);
    pre[v] = ++cnt;
    for (auto& e : (G[v]))
      if (e != p) dfs(G, e, v);
    post[v] = ++cnt;
  }
  bool isAncestor(int a, int b) {
    return pre[a] <= pre[b] && post[b] <= post[a];
  }
  int operator()(int a, int b) {
    for (int j = depth; j--;)
      if (!isAncestor(jumps[a][j], b)) a = jumps[a][j];
    return isAncestor(a, b) ? a : jumps[a][0];
  }
  int laq(int a, int lvl) {
    for (int j = depth; j--;)
      if (lvl <= level[jumps[a][j]]) a = jumps[a][j];
    return a;
  }
  int distance(int a, int b, int c) {
    return level[a] + level[b] - level[c] * 2;
  }
  int kthVertex(int a, int b, int c, int k) {
    if (level[a] - k >= level[c]) return laq(a, level[a] - k);
    k += level[c] * 2 - level[a];
    return (k > level[b] ? -1 : laq(b, k));
  }
};
vector<Vi> G;
vector<bool> good;
Vi comp;
void dfs(int v, int c) {
  if (!good[v] || comp[v] != -1) return;
  comp[v] = c;
  for (auto& e : (G[v])) dfs(e, c);
}
void addEdge(int i, int j) {
  G[i].push_back(j);
  G[j].push_back(i);
}
void run() {
  int n, k, r;
  cin >> n >> k >> r;
  G.resize(n * 2 - 1);
  for (int i = (0); i < (n - 1); i++) {
    int u, v;
    cin >> u >> v;
    addEdge(u - 1, n + i);
    addEdge(v - 1, n + i);
  }
  n = int((G).size());
  queue<int> que;
  Vi dist(n, -1);
  for (int i = (0); i < (r); i++) {
    int v;
    cin >> v;
    v--;
    que.push(v);
    dist[v] = 0;
  }
  while (!que.empty()) {
    int v = que.front();
    que.pop();
    for (auto& e : (G[v])) {
      if (dist[e] == -1) {
        dist[e] = dist[v] + 1;
        que.push(e);
      }
    }
  }
  good.resize(n);
  for (int i = (0); i < (n); i++) good[i] = dist[i] <= k;
  comp.resize(n, -1);
  int cnt = 0;
  for (int i = (0); i < (n); i++)
    if (comp[i] == -1) {
      dfs(i, cnt++);
    }
  LCA lca(G, 0);
  int q;
  cin >> q;
  while (q--) {
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    int c = lca(a, b);
    bool ok;
    if (lca.distance(a, b, c) <= k * 2) {
      ok = 1;
    } else {
      int u = lca.kthVertex(a, b, c, k);
      int v = lca.kthVertex(b, a, c, k);
      ok = (good[u] && good[v] && comp[u] == comp[v]);
    }
    cout << (ok ? "YES\n" : "NO\n");
  }
}

### Prompt

Develop a solution in Cpp to the problem described below:

Bessie is planning a vacation! In Cow-lifornia, there are n cities, with n-1 bidirectional roads connecting them. It is guaranteed that one can reach any city from any other city. 

Bessie is considering v possible vacation plans, with the i-th one consisting of a start city a_i and destination city b_i.

It is known that only r of the cities have rest stops. Bessie gets tired easily, and cannot travel across more than k consecutive roads without resting. In fact, she is so desperate to rest that she may travel through the same city multiple times in order to do so.

For each of the vacation plans, does there exist a way for Bessie to travel from the starting city to the destination city?

Input

The first line contains three integers n, k, and r (2 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ k,r ≤ n) — the number of cities, the maximum number of roads Bessie is willing to travel through in a row without resting, and the number of rest stops.

Each of the following n-1 lines contain two integers x_i and y_i (1 ≤ x_i, y_i ≤ n, x_i ≠ y_i), meaning city x_i and city y_i are connected by a road. 

The next line contains r integers separated by spaces — the cities with rest stops. Each city will appear at most once.

The next line contains v (1 ≤ v ≤ 2 ⋅ 10^5) — the number of vacation plans.

Each of the following v lines contain two integers a_i and b_i (1 ≤ a_i, b_i ≤ n, a_i ≠ b_i) — the start and end city of the vacation plan. 

Output

If Bessie can reach her destination without traveling across more than k roads without resting for the i-th vacation plan, print YES. Otherwise, print NO.

Examples

Input


6 2 1
1 2
2 3
2 4
4 5
5 6
2
3
1 3
3 5
3 6


Output


YES
YES
NO


Input


8 3 3
1 2
2 3
3 4
4 5
4 6
6 7
7 8
2 5 8
2
7 1
8 1


Output


YES
NO

Note

The graph for the first example is shown below. The rest stop is denoted by red.

For the first query, Bessie can visit these cities in order: 1, 2, 3.

For the second query, Bessie can visit these cities in order: 3, 2, 4, 5. 

For the third query, Bessie cannot travel to her destination. For example, if she attempts to travel this way: 3, 2, 4, 5, 6, she travels on more than 2 roads without resting.

<image>

The graph for the second example is shown below. 

<image>

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Vi = vector<int>;
using Pii = pair<int, int>;
int uplg(int n) { return 32 - __builtin_clz(n); }
int uplg(ll n) { return 64 - __builtin_clzll(n); }
void run();
int main() {
  cin.sync_with_stdio(0);
  cin.tie(0);
  cout << fixed << setprecision(18);
  run();
  return 0;
}
struct LCA {
  vector<Vi> jumps;
  Vi level, pre, post;
  int cnt{0}, depth;
  LCA() {}
  LCA(vector<Vi>& G, int root)
      : jumps(int((G).size())),
        level(int((G).size())),
        pre(int((G).size())),
        post(int((G).size())) {
    dfs(G, root, root);
    depth = int(log2(int((G).size()))) + 2;
    for (int j = (0); j < (depth); j++)
      for (auto& v : (jumps)) v.push_back(jumps[v[j]][j]);
  }
  void dfs(vector<Vi>& G, int v, int p) {
    level[v] = p == v ? 0 : level[p] + 1;
    jumps[v].push_back(p);
    pre[v] = ++cnt;
    for (auto& e : (G[v]))
      if (e != p) dfs(G, e, v);
    post[v] = ++cnt;
  }
  bool isAncestor(int a, int b) {
    return pre[a] <= pre[b] && post[b] <= post[a];
  }
  int operator()(int a, int b) {
    for (int j = depth; j--;)
      if (!isAncestor(jumps[a][j], b)) a = jumps[a][j];
    return isAncestor(a, b) ? a : jumps[a][0];
  }
  int laq(int a, int lvl) {
    for (int j = depth; j--;)
      if (lvl <= level[jumps[a][j]]) a = jumps[a][j];
    return a;
  }
  int distance(int a, int b, int c) {
    return level[a] + level[b] - level[c] * 2;
  }
  int kthVertex(int a, int b, int c, int k) {
    if (level[a] - k >= level[c]) return laq(a, level[a] - k);
    k += level[c] * 2 - level[a];
    return (k > level[b] ? -1 : laq(b, k));
  }
};
vector<Vi> G;
vector<bool> good;
Vi comp;
void dfs(int v, int c) {
  if (!good[v] || comp[v] != -1) return;
  comp[v] = c;
  for (auto& e : (G[v])) dfs(e, c);
}
void addEdge(int i, int j) {
  G[i].push_back(j);
  G[j].push_back(i);
}
void run() {
  int n, k, r;
  cin >> n >> k >> r;
  G.resize(n * 2 - 1);
  for (int i = (0); i < (n - 1); i++) {
    int u, v;
    cin >> u >> v;
    addEdge(u - 1, n + i);
    addEdge(v - 1, n + i);
  }
  n = int((G).size());
  queue<int> que;
  Vi dist(n, -1);
  for (int i = (0); i < (r); i++) {
    int v;
    cin >> v;
    v--;
    que.push(v);
    dist[v] = 0;
  }
  while (!que.empty()) {
    int v = que.front();
    que.pop();
    for (auto& e : (G[v])) {
      if (dist[e] == -1) {
        dist[e] = dist[v] + 1;
        que.push(e);
      }
    }
  }
  good.resize(n);
  for (int i = (0); i < (n); i++) good[i] = dist[i] <= k;
  comp.resize(n, -1);
  int cnt = 0;
  for (int i = (0); i < (n); i++)
    if (comp[i] == -1) {
      dfs(i, cnt++);
    }
  LCA lca(G, 0);
  int q;
  cin >> q;
  while (q--) {
    int a, b;
    cin >> a >> b;
    a--;
    b--;
    int c = lca(a, b);
    bool ok;
    if (lca.distance(a, b, c) <= k * 2) {
      ok = 1;
    } else {
      int u = lca.kthVertex(a, b, c, k);
      int v = lca.kthVertex(b, a, c, k);
      ok = (good[u] && good[v] && comp[u] == comp[v]);
    }
    cout << (ok ? "YES\n" : "NO\n");
  }
}

```