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;
int dx[] = {0, 1, -1, 0};
int dy[] = {1, 0, 0, -1};
long long pw(long long b, long long p) {
  if (!p) return 1;
  long long sq = pw(b, p / 2) % 1000000007;
  sq = (sq * sq) % 1000000007;
  if (p % 2) sq = (sq * b) % 1000000007;
  return sq;
}
const int N = 1e5 + 10, M = N * 2;
int euler[N * 2], idx;
int firstOcc[N];
int LG[N * 2];
int sparseTable[N * 2][18];
vector<vector<int>> adj(N);
int vis[N], vid;
int n, m;
int level[N];
struct node {
  int sum;
  node *l, *r;
  node() : sum(0), l(this), r(this) {}
  node(int s, node* l, node* r) : sum(s), l(l), r(r) {}
};
node* roots[N];
node* parRoot[N];
node* empty = new node();
node* insert(node* cur, int val, int st = 1, int end = 1e5 + 5) {
  if (val < st || val > end) {
    return cur;
  }
  if (st == end) {
    return new node(cur->sum + 1, empty, empty);
  }
  return new node(cur->sum + 1, insert(cur->l, val, st, ((end + st) >> 1)),
                  insert(cur->r, val, ((end + st) >> 1) + 1, end));
}
vector<int> p[N];
void dfs(int i, int lev, node* cur) {
  parRoot[i] = cur;
  for (auto j : p[i]) {
    cur = insert(cur, j);
  }
  roots[i] = cur;
  level[i] = lev;
  vis[i] = vid;
  euler[idx] = i;
  firstOcc[i] = idx++;
  for (auto j : adj[i]) {
    if (vis[j] != vid) {
      dfs(j, lev + 1, cur);
      euler[idx++] = i;
    }
  }
}
void build() {
  LG[0] = -1;
  for (int i = 0; i <= idx; i++) {
    LG[i + 1] = LG[i] + !(i & (i + 1));
    sparseTable[i][0] = i;
  }
  for (int j = 1; (1 << j) <= idx; j++) {
    for (int i = 0; i + (1 << j) <= idx; i++) {
      int x = sparseTable[i][j - 1];
      int y = sparseTable[i + (1 << (j - 1))][j - 1];
      sparseTable[i][j] = (level[euler[x]] < level[euler[y]] ? x : y);
    }
  }
}
int getMin(int st, int end) {
  if (st > end) swap(st, end);
  int len = end - st + 1;
  int lg = LG[len];
  int x = sparseTable[st][lg];
  int y = sparseTable[end - (1 << lg) + 1][lg];
  return (level[euler[x]] < level[euler[y]] ? x : y);
}
int LCA(int a, int b) { return euler[getMin(firstOcc[a], firstOcc[b])]; }
int getKth(node* a, node* b, node* lca, node* parlca, int k, int st = 1,
           int end = 1e5 + 5) {
  if (st == end) {
    return st;
  }
  int leftVal = a->l->sum + b->l->sum - lca->l->sum - parlca->l->sum;
  if (leftVal >= k) {
    return getKth(a->l, b->l, lca->l, parlca->l, k, st, ((end + st) >> 1));
  }
  return getKth(a->r, b->r, lca->r, parlca->r, k - leftVal,
                ((end + st) >> 1) + 1, end);
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(NULL);
  int q;
  cin >> n >> m >> q;
  for (int i = 0; i < n - 1; i++) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
  for (int i = 0; i < m; i++) {
    int x;
    cin >> x;
    p[x].push_back(i + 1);
  }
  vid++;
  dfs(1, 0, empty);
  build();
  while (q--) {
    int u, v, a;
    cin >> u >> v >> a;
    int lca = LCA(u, v);
    int x = roots[u]->sum + roots[v]->sum - roots[lca]->sum - parRoot[lca]->sum;
    int k = min(a, x);
    cout << k;
    for (int i = 1; i <= k; i++) {
      cout << " " << getKth(roots[u], roots[v], roots[lca], parRoot[lca], i);
    }
    cout << "\n";
  }
  return 0;
}