Problem: Recently Duff has been a soldier in the army. Malek is her commander.

Their country, Andarz Gu has n cities (numbered from 1 to n) and n - 1 bidirectional roads. Each road connects two different cities. There exist a unique path between any two cities.

There are also m people living in Andarz Gu (numbered from 1 to m). Each person has and ID number. ID number of i - th person is i and he/she lives in city number ci. Note that there may be more than one person in a city, also there may be no people living in the city.

<image>

Malek loves to order. That's why he asks Duff to answer to q queries. In each query, he gives her numbers v, u and a.

To answer a query:

Assume there are x people living in the cities lying on the path from city v to city u. Assume these people's IDs are p1, p2, ..., px in increasing order. 

If k = min(x, a), then Duff should tell Malek numbers k, p1, p2, ..., pk in this order. In the other words, Malek wants to know a minimums on that path (or less, if there are less than a people).

Duff is very busy at the moment, so she asked you to help her and answer the queries.

Input

The first line of input contains three integers, n, m and q (1 ≤ n, m, q ≤ 105).

The next n - 1 lines contain the roads. Each line contains two integers v and u, endpoints of a road (1 ≤ v, u ≤ n, v ≠ u).

Next line contains m integers c1, c2, ..., cm separated by spaces (1 ≤ ci ≤ n for each 1 ≤ i ≤ m).

Next q lines contain the queries. Each of them contains three integers, v, u and a (1 ≤ v, u ≤ n and 1 ≤ a ≤ 10).

Output

For each query, print numbers k, p1, p2, ..., pk separated by spaces in one line.

Examples

Input

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


Output

1 3
2 2 3
0
3 1 2 4
1 2

Note

Graph of Andarz Gu in the sample case is as follows (ID of people in each city are written next to them):

<image>

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int Nmax = 1e5 + 10;
const int maxlog = 16;
int n, m, q, i, nrc, act, T;
int lvl[Nmax], w[Nmax], fa[maxlog + 1][Nmax];
int lbl[Nmax], pos[Nmax], nod[Nmax << 2], len[Nmax], up[Nmax], add[Nmax];
vector<int> arb[Nmax << 2], ans[2], v[Nmax];
vector<int> g[Nmax];
void dfs(int node, int dad) {
  lvl[node] = lvl[dad] + 1;
  w[node] = 1;
  fa[0][node] = dad;
  for (int i = 1; i <= maxlog && (1 << i) <= lvl[node]; ++i)
    fa[i][node] = fa[i - 1][fa[i - 1][node]];
  for (auto &it : g[node]) {
    if (it == dad) continue;
    dfs(it, node);
    w[node] += w[it];
  }
}
void chains(int node) {
  lbl[node] = nrc;
  pos[node] = ++len[nrc];
  int maxx = 0, to = -1;
  for (auto &it : g[node]) {
    if (it == fa[0][node]) continue;
    if (w[it] > maxx) maxx = w[it], to = it;
  }
  if (to != -1) chains(to);
  for (auto &it : g[node]) {
    if (it == fa[0][node]) continue;
    if (it == to) continue;
    up[++nrc] = node;
    chains(it);
  }
}
int kanc(int x, int t) {
  for (int i = 0; i <= maxlog; ++i)
    if (t & (1 << i)) x = fa[i][x];
  return x;
}
int lca(int x, int y) {
  if (lvl[x] < lvl[y]) swap(x, y);
  x = kanc(x, lvl[x] - lvl[y]);
  if (x == y) return x;
  for (int i = maxlog; i >= 0; --i)
    if (fa[i][x] != fa[i][y]) x = fa[i][x], y = fa[i][y];
  return fa[0][x];
}
void interclaseaza(int ind1, int ind2, int ind3) {
  int dim1 = min((int)arb[ind1].size(), 10);
  int dim2 = min((int)arb[ind2].size(), 10);
  arb[ind3] = vector<int>(dim1 + dim2);
  merge(arb[ind1].begin(), arb[ind1].begin() + dim1, arb[ind2].begin(),
        arb[ind2].begin() + dim2, arb[ind3].begin());
}
void build(int node, int left, int right, int k) {
  if (left == right) {
    arb[add[k] + node] = v[nod[add[k] + left]];
    return;
  }
  int mid = (left + right) >> 1;
  build((node << 1), left, mid, k);
  build(((node << 1) | 1), mid + 1, right, k);
  interclaseaza(add[k] + (node << 1), add[k] + ((node << 1) | 1),
                add[k] + node);
}
void query(int node, int left, int right, int lq, int rq, int k) {
  if (lq <= left && right <= rq) {
    int dim = min((int)ans[act].size(), T);
    ans[!act] = vector<int>(dim + arb[add[k] + node].size());
    merge(ans[act].begin(), ans[act].begin() + dim, arb[add[k] + node].begin(),
          arb[add[k] + node].end(), ans[!act].begin());
    act ^= 1;
    return;
  }
  int mid = (left + right) >> 1;
  if (lq <= mid) query((node << 1), left, mid, lq, rq, k);
  if (mid < rq) query(((node << 1) | 1), mid + 1, right, lq, rq, k);
}
void go(int x, int y, int r) {
  if (lvl[x] < lvl[y]) return;
  int L = (lbl[y] == lbl[x]) ? pos[y] + r : 1;
  int R = pos[x];
  if (L <= R) query(1, 1, len[lbl[x]], L, R, lbl[x]);
  go(up[lbl[x]], y, r);
}
int main() {
  scanf("%d %d %d", &n, &m, &q);
  for (i = 1; i < n; ++i) {
    int x, y;
    scanf("%d %d", &x, &y);
    g[x].push_back(y);
    g[y].push_back(x);
  }
  for (i = 1; i <= m; ++i) {
    int x;
    scanf("%d", &x);
    v[x].push_back(i);
  }
  for (i = 1; i <= n; ++i) {
    int dim = min((int)v[i].size(), 10);
    v[i].resize(dim);
  }
  dfs(1, 0);
  nrc = 1;
  chains(1);
  for (i = 2; i <= nrc + 1; ++i) add[i] = add[i - 1] + (len[i - 1] << 2);
  for (i = 1; i <= n; ++i) nod[add[lbl[i]] + pos[i]] = i;
  for (i = 1; i <= nrc; ++i) build(1, 1, len[i], i);
  for (i = 1; i <= q; ++i) {
    int x, y;
    scanf("%d %d %d", &x, &y, &T);
    act = 0;
    ans[act].clear();
    int z = lca(x, y);
    if (z == x)
      go(y, z, 0);
    else if (z == y)
      go(x, z, 0);
    else
      go(x, z, 0), go(y, z, 1);
    printf("%d ", min((int)ans[act].size(), T));
    for (int j = 0; j < min((int)ans[act].size(), T); ++j)
      printf("%d ", ans[act][j]);
    printf("\n");
  }
  return 0;
}