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 maxn = 100000 + 10000;
const int maxm = 2000000;
struct Tree {
  int lson, rson, sum;
} tree[maxm];
int tot = 0, n, m, q, u, v, a;
int T[maxn], fa[maxn];
vector<int> city[maxn], G[maxn], num[maxn], query[maxn];
struct question {
  int u, v, k;
} quest[maxn];
int build(int left, int right) {
  int rt = tot++;
  tree[rt].sum = 0;
  if (left != right) {
    int mid = (left + right) / 2;
    tree[rt].lson = build(left, mid);
    tree[rt].rson = build(mid + 1, right);
  }
  return rt;
}
int insert(int rt, int pos, int value) {
  int newrt = tot++, tmp = newrt;
  int left = 1, right = m;
  tree[newrt].sum = tree[rt].sum + value;
  while (left < right) {
    int mid = (left + right) / 2;
    if (pos <= mid) {
      tree[newrt].lson = tot++;
      tree[newrt].rson = tree[rt].rson;
      newrt = tree[newrt].lson;
      rt = tree[rt].lson;
      right = mid;
    } else {
      tree[newrt].rson = tot++;
      tree[newrt].lson = tree[rt].lson;
      newrt = tree[newrt].rson;
      rt = tree[rt].rson;
      left = mid + 1;
    }
    tree[newrt].sum = tree[rt].sum + value;
  }
  return tmp;
}
void dfs_zxtree(int cur, int pa) {
  for (int i = 0; i < G[cur].size(); i++) {
    int next = G[cur][i];
    if (next == pa) continue;
    T[next] = T[cur];
    for (int j = 0; j < city[next].size(); j++)
      T[next] = insert(T[next], city[next][j], 1);
    dfs_zxtree(next, cur);
  }
}
bool vis[maxn];
int pnt[maxn], lca[maxn];
int find(int x) { return pnt[x] == x ? x : pnt[x] = find(pnt[x]); }
void dfs_lca(int u) {
  vis[u] = 1;
  pnt[u] = u;
  for (int i = 0; i < G[u].size(); i++) {
    int next = G[u][i];
    if (vis[next]) continue;
    fa[next] = T[u];
    dfs_lca(next);
    pnt[next] = u;
  }
  for (int i = 0; i < query[u].size(); i++) {
    int next = query[u][i];
    if (vis[next]) lca[num[u][i]] = find(next);
  }
}
int Query(int leftrt, int rightrt, int lca, int k) {
  int left = 1, right = m, lcart = T[lca], fart = fa[lca];
  int temp =
      tree[leftrt].sum + tree[rightrt].sum - tree[lcart].sum - tree[fart].sum;
  if (temp < k) return -1;
  while (left < right) {
    int mid = (left + right) / 2;
    int temp = tree[tree[leftrt].lson].sum + tree[tree[rightrt].lson].sum -
               tree[tree[lcart].lson].sum - tree[tree[fart].lson].sum;
    if (temp >= k) {
      right = mid;
      leftrt = tree[leftrt].lson;
      rightrt = tree[rightrt].lson;
      lcart = tree[lcart].lson;
      fart = tree[fart].lson;
    } else {
      left = mid + 1;
      k -= temp;
      leftrt = tree[leftrt].rson;
      rightrt = tree[rightrt].rson;
      lcart = tree[lcart].rson;
      fart = tree[fart].rson;
    }
  }
  return left;
}
int main(int argc, char* argv[]) {
  scanf("%d %d %d", &n, &m, &q);
  for (int i = 0; i < n - 1; i++) {
    scanf("%d %d", &u, &v);
    G[u].push_back(v);
    G[v].push_back(u);
  }
  for (int i = 1; i <= m; i++) {
    scanf("%d", &u);
    city[u].push_back(i);
  }
  build(1, m);
  T[1] = T[0];
  for (int i = 0; i < city[1].size(); i++) T[1] = insert(T[1], city[1][i], 1);
  dfs_zxtree(1, -1);
  for (int i = 0; i < q; i++) {
    scanf("%d %d %d", &quest[i].u, &quest[i].v, &quest[i].k);
    query[quest[i].u].push_back(quest[i].v);
    query[quest[i].v].push_back(quest[i].u);
    num[quest[i].u].push_back(i);
    num[quest[i].v].push_back(i);
  }
  fa[1] = T[0];
  dfs_lca(1);
  for (int i = 0; i < q; i++) {
    int cnt = 0;
    vector<int> ans;
    for (int j = 1; j <= quest[i].k; j++) {
      int temp = Query(T[quest[i].u], T[quest[i].v], lca[i], j);
      if (temp > 0)
        ans.push_back(temp);
      else
        break;
    }
    printf("%d", ans.size());
    for (int j = 0; j < ans.size(); j++) printf(" %d", ans[j]);
    printf("\n");
  }
  return 0;
}