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>
#include <bits/stdc++.h>
using namespace std;
int WhichLink[100010];
int Position[100010];
int HeadOfLink[100010];
vector<int> mytree;
vector<int> who;
int SubtreeSize[100010];
int Parent[100010];
bool Visited[100010];
vector<int> AdjList[100010];
int N;
int dp[100010][20];
int level[100010];
void dfsUtility(int node, int dad, int depth) {
  Visited[node] = true;
  Parent[node] = dad;
  level[node] = depth;
  for (int i = 0; i < AdjList[node].size(); i++) {
    if (!Visited[AdjList[node][i]]) {
      dfsUtility(AdjList[node][i], node, depth + 1);
      SubtreeSize[node] += SubtreeSize[AdjList[node][i]];
    }
  }
  SubtreeSize[node]++;
}
int TotalChains = 1;
vector<int> arr[100010];
void HLD(int currChain, int node) {
  if (HeadOfLink[currChain] == 0) HeadOfLink[currChain] = node;
  mytree.push_back(arr[node][0]);
  who.push_back(node);
  WhichLink[node] = currChain;
  Position[node] = mytree.size() - 1;
  int MaxHere = -1, PosHere = -1;
  for (int i = 0; i < AdjList[node].size(); i++) {
    if (AdjList[node][i] != Parent[node] &&
        SubtreeSize[AdjList[node][i]] > MaxHere) {
      MaxHere = SubtreeSize[AdjList[node][i]];
      PosHere = i;
    }
  }
  if (PosHere != -1) HLD(currChain, AdjList[node][PosHere]);
  for (int i = 0; i < AdjList[node].size(); i++) {
    if (i != PosHere && AdjList[node][i] != Parent[node]) {
      TotalChains++;
      HLD(TotalChains, AdjList[node][i]);
    }
  }
}
struct nodes {
  int val, pos;
  int kids, lazy;
  void split(nodes& left, nodes& right) {
    if (lazy) {
    }
    lazy = 0;
  }
};
struct SegmentTree {
  vector<nodes> tree;
  nodes identity;
  SegmentTree(void) {
    identity.val = 1000000007;
    identity.pos = -1;
    identity.lazy = identity.kids = 0;
    tree.resize(100010 * 4);
  }
  nodes merge(nodes& l, nodes& r) {
    nodes ret;
    if (l.val < r.val)
      ret.pos = l.pos;
    else
      ret.pos = r.pos;
    ret.val = min(l.val, r.val);
    ret.lazy = 0;
    ret.kids = l.kids + r.kids;
    return ret;
  }
  void build(int node, int start, int end) {
    if (start == end) {
      tree[node].val = mytree[start];
      tree[node].kids = 1;
      tree[node].pos = start;
      tree[node].lazy = 0;
      return;
    }
    int mid = (start + end) / 2;
    build((node << 1), start, mid);
    build(((node << 1) + 1), mid + 1, end);
    tree[node] = merge(tree[(node << 1)], tree[((node << 1) + 1)]);
  }
  void update(int node, int start, int end, int left, int right, int val) {
    if (start > end or left > end or right < start) return;
    if (start >= left and end <= right) {
      tree[node].val = val;
      tree[node].lazy = 1;
      return;
    }
    tree[node].split(tree[(node << 1)], tree[((node << 1) + 1)]);
    int mid = (start + end) / 2;
    update((node << 1), start, mid, left, right, val);
    update(((node << 1) + 1), mid + 1, end, left, right, val);
    tree[node] = merge(tree[(node << 1)], tree[((node << 1) + 1)]);
  }
  nodes query(int node, int start, int end, int left, int right) {
    if (start > end or left > end or right < start) return identity;
    if (start >= left and end <= right) return tree[node];
    tree[node].split(tree[(node << 1)], tree[((node << 1) + 1)]);
    int mid = (start + end) / 2;
    nodes a, b, ret;
    a = query((node << 1), start, mid, left, right);
    b = query(((node << 1) + 1), mid + 1, end, left, right);
    ret = merge(a, b);
    return ret;
  }
};
SegmentTree ST;
void preprocess(void) {
  for (int i = 1; i <= N; i++) {
    for (int j = 0; j < 20; j++) dp[i][j] = -1;
  }
  for (int i = 1; i <= N; i++) {
    dp[i][0] = Parent[i];
  }
  for (int j = 1; (1 << j) <= N; j++) {
    for (int i = 1; i <= N; i++) {
      if (dp[i][j - 1] != -1) dp[i][j] = dp[dp[i][j - 1]][j - 1];
    }
  }
}
int lca(int p, int q) {
  if (level[p] < level[q]) swap(p, q);
  int foo;
  for (foo = 1; (1 << foo) <= level[p]; foo++)
    ;
  foo--;
  for (int i = foo; i >= 0; i--) {
    if (level[p] - (1 << i) >= level[q]) p = dp[p][i];
  }
  if (p == q) return p;
  for (int i = foo; i >= 0; i--) {
    if (dp[p][i] != -1 and dp[p][i] != dp[q][i]) {
      p = dp[p][i];
      q = dp[q][i];
    }
  }
  return Parent[p];
}
pair<int, int> queryup(int a, int b) {
  int ret = 1000000007;
  int idx = -1;
  while (WhichLink[a] != WhichLink[b]) {
    int boss = HeadOfLink[WhichLink[a]];
    nodes P = ST.query(1, 0, N - 1, Position[boss], Position[a]);
    if (P.val < ret) {
      ret = P.val;
      idx = P.pos;
    }
    a = Parent[boss];
  }
  nodes P = ST.query(1, 0, N - 1, Position[b], Position[a]);
  if (P.val < ret) {
    ret = P.val;
    idx = P.pos;
  }
  return pair<int, int>(ret, idx);
}
vector<int> store, currans;
int nextpos[100010];
int query(int a, int b, int l) {
  pair<int, int> A, B;
  A = queryup(a, l);
  B = queryup(b, l);
  if (min(A.first, B.first) == 1000000007) return 1000000007;
  if (A.first < B.first) {
    store.push_back(A.second);
    currans.push_back(A.first);
    nextpos[who[A.second]]++;
    ST.update(1, 0, N - 1, A.second, A.second,
              arr[who[A.second]][nextpos[who[A.second]]]);
    return A.first;
  } else {
    store.push_back(B.second);
    currans.push_back(B.first);
    nextpos[who[B.second]]++;
    ST.update(1, 0, N - 1, B.second, B.second,
              arr[who[B.second]][nextpos[who[B.second]]]);
    return B.first;
  }
}
int M, Q;
inline void ReadInput(void) {
  scanf("%d", &N);
  scanf("%d", &M);
  scanf("%d", &Q);
  for (int i = 1; i < N; i++) {
    int a, b;
    scanf("%d", &a);
    scanf("%d", &b);
    AdjList[a].push_back(b);
    AdjList[b].push_back(a);
  }
  for (int i = 1; i <= M; i++) {
    int a;
    scanf("%d", &a);
    arr[a].push_back(i);
  }
}
inline void solve(void) {
  fill(Visited, Visited + 100010, false);
  for (int i = 1; i <= N; i++) {
    arr[i].push_back(1000000007);
    sort(arr[i].begin(), arr[i].end());
    nextpos[i] = 0;
  }
  dfsUtility(1, 0, 0);
  HLD(1, 1);
  ST.build(1, 0, N - 1);
  preprocess();
  while (Q--) {
    int a, b, l, c;
    scanf("%d", &a);
    scanf("%d", &b);
    scanf("%d", &c);
    l = lca(a, b);
    for (int i = 1; i <= c; i++) {
      int ret = query(a, b, l);
      if (ret == 1000000007) break;
    }
    printf("%d ", (int)store.size());
    for (int i = 0; i < store.size(); i++) {
      printf("%d ", currans[i]);
      nextpos[who[store[i]]]--;
    }
    for (int i = 0; i < store.size(); i++) {
      int u = nextpos[who[store[i]]];
      ST.update(1, 0, N - 1, store[i], store[i], arr[who[store[i]]][u]);
    }
    printf("\n");
    store.clear();
    currans.clear();
  }
}
inline void Refresh(void) {}
int main() {
  ReadInput();
  solve();
  return 0;
}
