Problem: 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

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
#pragma GCC optimize(3)
#pragma GCC optimize("inline")
using namespace std;
const int N = 1005000;
template <typename T>
void read(T &x) {
  x = 0;
  bool f = 0;
  char c = getchar();
  for (; !isdigit(c); c = getchar())
    if (c == '-') f = 1;
  for (; isdigit(c); c = getchar()) x = (x << 3) + (x << 1) + (c ^ 48);
  if (f) x = -x;
}
int n, m;
int h[N], ne[N], to[N];
int dep[N], tot;
inline void add(int x, int y) { ne[++tot] = h[x], to[h[x] = tot] = y; }
int siz[N], f[N], son[N];
int Top[N], a[N], s[N], top;
void dfs1(int x, int fa) {
  siz[x] = 1, f[x] = fa, dep[x] = dep[fa] + 1;
  for (int i = h[x]; i; i = ne[i]) {
    int y = to[i];
    if (y == fa) continue;
    dfs1(y, x), siz[x] += siz[y];
    if (siz[y] > siz[son[x]]) son[x] = y;
  }
}
int dfn[N], num;
void dfs2(int x, int topf) {
  Top[x] = topf, dfn[x] = ++num;
  if (!son[x]) return;
  dfs2(son[x], topf);
  for (int i = h[x]; i; i = ne[i])
    if (!dfn[to[i]]) dfs2(to[i], to[i]);
}
int Lca(int x, int y) {
  while (Top[x] != Top[y]) {
    if (dep[Top[x]] < dep[Top[y]]) swap(x, y);
    x = f[Top[x]];
  }
  return dep[x] < dep[y] ? x : y;
}
bool cmp(int a, int b) { return dfn[a] < dfn[b]; }
vector<int> v[N];
inline void add_e(int x, int y) {
  v[x].push_back(y);
  v[y].push_back(x);
}
void ins(int x) {
  if (top == 1) return (void)(s[++top] = x);
  int lca = Lca(x, s[top]);
  if (lca == s[top]) return (void)(s[++top] = x);
  while (top > 1 && dfn[s[top - 1]] >= dfn[lca])
    add_e(s[top - 1], s[top]), top--;
  if (lca != s[top]) add_e(lca, s[top]), s[top] = lca;
  s[++top] = x;
}
int ask[N], vis[N];
struct node {
  int col, v, di, ti;
  bool operator<(const node &j) const {
    if (ti != j.ti) return ti < j.ti;
    if (col != j.col) return col < j.col;
    return di > j.di;
  }
} qaq[N], I;
inline int Dis(int x, int y) { return dep[x] + dep[y] - 2 * dep[Lca(x, y)]; }
node To(int x, int y) {
  int dis = Dis(x, y);
  node tmp = qaq[x];
  if (dis <= qaq[x].di) {
    tmp.di -= dis;
    return tmp;
  }
  dis -= qaq[x].di;
  int t = (dis - 1) / qaq[x].v + 1;
  tmp.di = t * qaq[x].v - dis, tmp.ti += t;
  return tmp;
}
struct QWQ {
  node p;
  int x;
  bool operator<(const QWQ &j) const { return j.p < p; }
};
priority_queue<QWQ> q;
int T;
inline bool Cmp(node a, QWQ b) { return a < b.p; }
void diji(void) {
  while (q.size()) {
    QWQ x = q.top();
    q.pop();
    if (Cmp(qaq[x.x], x)) continue;
    for (auto y : v[x.x]) {
      node t = To(x.x, y);
      if (t < qaq[y]) {
        qaq[y] = t;
        q.push((QWQ){qaq[y], y});
      }
    }
  }
}
void refresh(int x, int f) {
  for (auto i : v[x]) {
    if (i == f) continue;
    refresh(i, x);
  }
  v[x].clear();
  qaq[x] = I;
}
void init(int m, int k) {
  int cnt = m;
  for (int i = 1; i <= m; i++) {
    read(a[i]), qaq[a[i]].col = i, read(qaq[a[i]].v);
    qaq[a[i]].ti = 0;
    q.push((QWQ){qaq[a[i]], a[i]});
  }
  for (int i = 1; i <= k; i++) read(ask[i]), a[++cnt] = ask[i];
  sort(a + 1, a + cnt + 1, cmp);
  s[top = 1] = a[0] = 1;
  for (int i = 1; i <= cnt; i++) {
    if (a[i] == a[i - 1]) continue;
    ins(a[i]);
  }
  while (top > 0) add_e(s[top - 1], s[top]), top--;
}
int main() {
  read(n);
  for (int i = 1; i < n; i++) {
    int x, y;
    read(x), read(y);
    add(x, y);
    add(y, x);
  }
  dfs1(1, 0), dfs2(1, 1);
  I.col = n + 1, I.ti = n + 1;
  for (int i = 1; i <= n; i++) qaq[i] = I;
  int ww;
  read(ww);
  while (ww--) {
    int k, m;
    read(m), read(k);
    init(m, k), diji();
    for (int i = 1; i <= k; i++) printf("%d ", qaq[ask[i]].col);
    putchar('\n');
    refresh(1, 0);
  }
  return 0;
}