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;
const int N = 200010;
struct edge {
  int to, next;
} e[N * 2];
int head[N], ecnt;
inline void adde(int from, int to) {
  e[++ecnt] = (edge){to, head[from]}, head[from] = ecnt;
  e[++ecnt] = (edge){from, head[to]}, head[to] = ecnt;
}
int dep[N], fa[N][18], dfn[N], dfsn;
void dfs(int u, int f) {
  fa[u][0] = f, dep[u] = dep[f] + 1, dfn[u] = ++dfsn;
  for (int i = 1; i <= 17; i++) fa[u][i] = fa[fa[u][i - 1]][i - 1];
  for (int i = head[u]; i; i = e[i].next)
    if (e[i].to != f) dfs(e[i].to, u);
}
inline int LCA(int a, int b) {
  if (dep[a] < dep[b]) swap(a, b);
  for (int i = 17; i >= 0; i--)
    if (dep[fa[a][i]] >= dep[b]) a = fa[a][i];
  if (a == b) return a;
  for (int i = 17; i >= 0; i--)
    if (fa[a][i] != fa[b][i]) a = fa[a][i], b = fa[b][i];
  return fa[a][0];
}
inline int Dis(int a, int b) { return dep[a] + dep[b] - 2 * dep[LCA(a, b)]; }
int col[N], remain[N], s[N], mark[N];
long long turn[N];
vector<pair<int, int> > G[N];
vector<int> pool;
inline void adde(int from, int to, int w) {
  pool.push_back(from), pool.push_back(to);
  G[from].push_back(pair<int, int>(to, w)),
      G[to].push_back(pair<int, int>(from, w));
}
inline void clear() {
  for (auto t : pool) col[t] = remain[t] = turn[t] = mark[t] = 0, G[t].clear();
  pool.clear();
}
inline int build(vector<int> p) {
  sort(p.begin(), p.end(), [](int a, int b) { return dfn[a] < dfn[b]; });
  p.resize(unique(p.begin(), p.end()) - p.begin());
  static int stk[N];
  int top = 0, lca;
  for (auto v : p) {
    if ((!top) || (lca = LCA(v, stk[top])) == stk[top]) {
      stk[++top] = v;
      continue;
    }
    while (top >= 2 && dep[stk[top - 1]] >= dep[lca])
      adde(stk[top], stk[top - 1], dep[stk[top]] - dep[stk[top - 1]]), top--;
    if (stk[top] != lca)
      adde(stk[top], lca, dep[stk[top]] - dep[lca]), stk[top] = lca;
    stk[++top] = v;
  }
  for (int i = 1; i < top; i++)
    adde(stk[i], stk[i + 1], dep[stk[i + 1]] - dep[stk[i]]);
  return stk[1];
}
int k;
inline int get(int r, int v, int d) {
  if (d <= r) return 0;
  return (d - r + v - 1) / v;
}
void up(int u, int f) {
  for (auto v : G[u])
    if (v.first != f) {
      up(v.first, u);
      if ((!col[v.first]) || mark[u]) continue;
      int t = get(remain[v.first], s[col[v.first]], v.second);
      long long nxt = (long long)t * k + turn[v.first];
      if ((!col[u]) || nxt < turn[u])
        turn[u] = nxt, col[u] = col[v.first],
        remain[u] = remain[v.first] + (long long)t * s[col[v.first]] - v.second;
    }
}
void down(int u, int f) {
  assert(col[u]);
  for (auto v : G[u])
    if (v.first != f) {
      int t = get(remain[u], s[col[u]], v.second);
      long long nxt = t * k + turn[u];
      if ((!mark[v.first]) && (turn[v.first] > nxt || !col[v.first]))
        turn[v.first] = nxt, col[v.first] = col[u],
        remain[v.first] = remain[u] + (long long)t * s[col[u]] - v.second;
      down(v.first, u);
    }
}
int main() {
  int n;
  scanf("%d", &n);
  for (int i = 1, a, b; i < n; i++) scanf("%d%d", &a, &b), adde(a, b);
  int q;
  scanf("%d", &q), dfs(1, 0);
  while (q--) {
    vector<int> tmp = {1}, ask;
    int m;
    scanf("%d%d", &k, &m);
    for (int i = 1; i <= k; i++) {
      int a;
      scanf("%d%d", &a, &s[i]), tmp.push_back(a);
      col[a] = turn[a] = i, remain[a] = s[i], mark[a] = 1;
    }
    for (int i = 1; i <= m; i++) {
      int a;
      scanf("%d", &a), ask.push_back(a), tmp.push_back(a);
    }
    if (n <= 10) {
      for (int i = 1; i <= n; i++) {
        pool.push_back(i);
        for (int j = head[i]; j; j = e[j].next)
          if (i < e[j].to) adde(i, e[j].to, 1);
      }
    } else
      build(tmp);
    up(1, 0), down(1, 0);
    for (auto t : ask) printf("%d ", col[t]);
    clear(), puts("");
  }
  return 0;
}
