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 = 1e5 + 5;
const int maxdep = 20;
int par[maxdep][maxn], dep[maxn], n;
vector<int> ID[maxdep][maxn], cit[maxn];
vector<int> G[maxn];
void init() {
  for (int i = 0; i < maxn; i++) {
    G[i].clear();
    cit[i].clear();
    for (int j = 0; j < maxdep; j++) {
      ID[j][i].clear();
    }
  }
  memset(par, -1, sizeof(par));
}
void update(vector<int> &v1, vector<int> &v2) {
  for (int x : v2) {
    v1.push_back(x);
  }
  sort(v1.begin(), v1.end());
  v1.erase(unique(v1.begin(), v1.end()), v1.end());
  while (v1.size() > 10) {
    v1.pop_back();
  }
}
void dfs(int u, int father) {
  par[0][u] = father;
  dep[u] = dep[father] + 1;
  for (int i = u; i <= u; i++) {
    update(ID[0][i], cit[par[0][i]]);
    update(ID[0][i], cit[i]);
    for (int j = 0; j + 1 < maxdep; j++) {
      if (~par[j][i]) {
        par[j + 1][i] = par[j][par[j][i]];
        update(ID[j + 1][i], cit[i]);
        update(ID[j + 1][i], ID[j][i]);
        update(ID[j + 1][i], ID[j][par[j][i]]);
      } else {
        par[j + 1][i] = -1;
      }
    }
  }
  for (int v : G[u]) {
    if (v != father) {
      dfs(v, u);
    }
  }
}
int lca(int u, int v) {
  if (dep[u] > dep[v]) {
    swap(u, v);
  }
  for (int k = 0; k < maxdep; k++) {
    if ((dep[v] - dep[u]) >> k & 1) {
      v = par[k][v];
    }
  }
  if (u == v) {
    return u;
  }
  for (int i = maxdep - 1; i >= 0; i--) {
    if (par[i][u] != par[i][v]) {
      u = par[i][u];
      v = par[i][v];
    }
  }
  return par[0][u];
}
int anc;
vector<int> solve(int u, int v) {
  vector<int> res;
  if (u == v) {
    update(res, cit[u]);
  }
  for (int i = maxdep - 1; i >= 0; i--) {
    if (~par[i][u] && dep[par[i][u]] >= dep[anc]) {
      update(res, ID[i][u]);
      u = par[i][u];
    }
  }
  for (int i = maxdep - 1; i >= 0; i--) {
    if (~par[i][v] && dep[par[i][v]] >= dep[anc]) {
      update(res, ID[i][v]);
      v = par[i][v];
    }
  }
  vector<int> emp;
  update(res, emp);
  return res;
}
int main() {
  int m, q;
  while (~scanf("%d%d%d", &n, &m, &q)) {
    init();
    for (int i = 0; i < n - 1; i++) {
      int u, v;
      scanf("%d%d", &u, &v);
      G[u].push_back(v);
      G[v].push_back(u);
    }
    for (int i = 0; i < m; i++) {
      int c;
      scanf("%d", &c);
      if (cit[c].size() < 10) {
        cit[c].push_back(i + 1);
        ID[0][c].push_back(i + 1);
      }
    }
    dfs(1, 0);
    while (q--) {
      int u, v, a;
      scanf("%d%d%d", &u, &v, &a);
      anc = lca(u, v);
      auto res = solve(u, v);
      int tot = min((int)res.size(), a);
      printf("%d%c", tot, " \n"[!tot]);
      for (int i = 0; i < min((int)res.size(), a); i++) {
        printf("%d%c", res[i], " \n"[i + 1 == min((int)res.size(), a)]);
      }
    }
  }
  return 0;
}