There are n cities in Treeland connected with n - 1 bidirectional roads in such that a way that any city is reachable from any other; in other words, the graph of cities and roads is a tree. Treeland is preparing for a seasonal virus epidemic, and currently, they are trying to evaluate different infection scenarios.

In each scenario, several cities are initially infected with different virus species. Suppose that there are k_i virus species in the i-th scenario. Let us denote v_j the initial city for the virus j, and s_j the propagation speed of the virus j. The spread of the viruses happens in turns: first virus 1 spreads, followed by virus 2, and so on. After virus k_i spreads, the process starts again from virus 1.

A spread turn of virus j proceeds as follows. For each city x not infected with any virus at the start of the turn, at the end of the turn it becomes infected with virus j if and only if there is such a city y that:

  * city y was infected with virus j at the start of the turn;
  * the path between cities x and y contains at most s_j edges;
  * all cities on the path between cities x and y (excluding y) were uninfected with any virus at the start of the turn.



Once a city is infected with a virus, it stays infected indefinitely and can not be infected with any other virus. The spread stops once all cities are infected.

You need to process q independent scenarios. Each scenario is described by k_i virus species and m_i important cities. For each important city determine which the virus it will be infected by in the end.

Input

The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^5) — the number of cities in Treeland.

The following n - 1 lines describe the roads. The i-th of these lines contains two integers x_i and y_i (1 ≤ x_i, y_i ≤ n) — indices of cities connecting by the i-th road. It is guaranteed that the given graph of cities and roads is a tree.

The next line contains a single integer q (1 ≤ q ≤ 2 ⋅ 10^5) — the number of infection scenarios. q scenario descriptions follow.

The description of the i-th scenario starts with a line containing two integers k_i and m_i (1 ≤ k_i, m_i ≤ n) — the number of virus species and the number of important cities in this scenario respectively. It is guaranteed that ∑_{i = 1}^ q k_i and ∑_{i = 1}^ q m_i do not exceed 2 ⋅ 10^5.

The following k_i lines describe the virus species. The j-th of these lines contains two integers v_j and s_j (1 ≤ v_j ≤ n, 1 ≤ s_j ≤ 10^6) – the initial city and the propagation speed of the virus species j. It is guaranteed that the initial cities of all virus species within a scenario are distinct.

The following line contains m_i distinct integers u_1, …, u_{m_i} (1 ≤ u_j ≤ n) — indices of important cities.

Output

Print q lines. The i-th line should contain m_i integers — indices of virus species that cities u_1, …, u_{m_i} are infected with at the end of the i-th scenario.

Example

Input


7
1 2
1 3
2 4
2 5
3 6
3 7
3
2 2
4 1
7 1
1 3
2 2
4 3
7 1
1 3
3 3
1 1
4 100
7 100
1 2 3


Output


1 2
1 1
1 1 1
#include <bits/stdc++.h>
using namespace std;
template <typename _T>
inline void read(_T &f) {
  f = 0;
  _T fu = 1;
  char c = getchar();
  while (c < '0' || c > '9') {
    if (c == '-') {
      fu = -1;
    }
    c = getchar();
  }
  while (c >= '0' && c <= '9') {
    f = (f << 3) + (f << 1) + (c & 15);
    c = getchar();
  }
  f *= fu;
}
template <typename T>
void print(T x) {
  if (x < 0) putchar('-'), x = -x;
  if (x < 10)
    putchar(x + 48);
  else
    print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
  print(x);
  putchar(t);
}
const int N = 2e5 + 5, INF = 0x7fffffff;
struct ele {
  int u, dis, col;
  ele(int a = 0, int b = 0, int c = 0) : u(a), dis(b), col(c) {}
};
priority_queue<ele> Q;
vector<int> adj[N];
vector<pair<int, int> > fuck[N];
int fa[N][18], tops[N], dep[N], po[N], st[N], used[N], col[N], v[N], s[N],
    dis[N], qry[N];
int n, m1, m2, q, dfn, top, len;
bool operator<(ele a, ele b) {
  if (a.dis >= 0 && b.dis >= 0) {
    if ((a.dis + s[abs(a.col)] - 1) / s[abs(a.col)] !=
        (b.dis + s[abs(b.col)] - 1) / s[abs(b.col)])
      return (a.dis + s[abs(a.col)] - 1) / s[abs(a.col)] <
             (b.dis + s[abs(b.col)] - 1) / s[abs(b.col)];
  } else {
    a.dis = -a.dis;
    b.dis = -b.dis;
    if ((a.dis + s[abs(a.col)] - 1) / s[abs(a.col)] !=
        (b.dis + s[abs(b.col)] - 1) / s[abs(b.col)])
      return (a.dis + s[abs(a.col)] - 1) / s[abs(a.col)] >
             (b.dis + s[abs(b.col)] - 1) / s[abs(b.col)];
  }
  return a.col < b.col;
}
void dfs1(int u) {
  tops[u] = ++dfn;
  for (int i = 1; i <= 17; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
  for (auto v : adj[u]) {
    if (v == fa[u][0]) continue;
    fa[v][0] = u;
    dep[v] = dep[u] + 1;
    dfs1(v);
  }
}
int lca(int u, int v) {
  if (dep[u] < dep[v]) swap(u, v);
  for (int i = 17; i >= 0; i--) {
    if (dep[fa[u][i]] >= dep[v]) {
      u = fa[u][i];
    }
  }
  if (u == v) return u;
  for (int i = 17; i >= 0; i--) {
    if (fa[u][i] != fa[v][i]) {
      u = fa[u][i];
      v = fa[v][i];
    }
  }
  return fa[u][0];
}
bool cmp(int x, int y) { return tops[x] < tops[y]; }
void addedge(int u, int v) {
  fuck[u].emplace_back(v, abs(dep[u] - dep[v]));
  fuck[v].emplace_back(u, abs(dep[u] - dep[v]));
}
int main() {
  read(n);
  for (int i = 1; i < n; i++) {
    int u, v;
    read(u);
    read(v);
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
  dep[1] = 1;
  dfs1(1);
  read(q);
  while (q--) {
    read(m1);
    read(m2);
    len = 0;
    for (int i = 1; i <= m1; i++)
      read(v[i]), read(s[i]), used[v[i]] = 1, po[++len] = v[i];
    for (int i = 1; i <= m2; i++) {
      read(qry[i]);
      if (!used[qry[i]]) {
        used[qry[i]] = 1;
        po[++len] = qry[i];
      }
    }
    sort(po + 1, po + len + 1, cmp);
    st[top = 1] = 1;
    fuck[1].clear();
    dis[1] = INF;
    for (int i = 1; i <= len; i++) {
      if (po[i] == 1) continue;
      int tmp = lca(po[i], st[top]);
      if (tmp != st[top]) {
        while (dep[tmp] < dep[st[top - 1]]) {
          addedge(st[top - 1], st[top]);
          --top;
        }
        if (dep[tmp] > dep[st[top - 1]]) {
          fuck[tmp].clear();
          dis[tmp] = INF;
          addedge(tmp, st[top]);
          st[top] = tmp;
        } else {
          addedge(st[top - 1], st[top]), --top;
        }
      }
      fuck[po[i]].clear();
      dis[po[i]] = INF;
      st[++top] = po[i];
    }
    while (top > 1) {
      addedge(st[top - 1], st[top]), --top;
    }
    for (int i = 1; i <= m1; i++)
      dis[v[i]] = 0, col[v[i]] = i, Q.push(ele(v[i], 0, -i));
    while (!Q.empty()) {
      ele u = Q.top();
      Q.pop();
      if (-u.dis != dis[u.u] || -u.col != col[u.u]) continue;
      for (auto i : fuck[u.u]) {
        ele go = ele(i.first, dis[u.u] + i.second, col[u.u]);
        if (dis[i.first] == INF ||
            go < ele(i.first, dis[i.first], col[i.first])) {
          dis[i.first] = go.dis;
          col[i.first] = go.col;
          Q.push(ele(go.u, -go.dis, -go.col));
        }
      }
    }
    for (int i = 1; i <= m2; i++) print(col[qry[i]], i == m2 ? '\n' : ' ');
    for (int i = 1; i <= len; i++) used[po[i]] = 0;
  }
  return 0;
}
