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;
const int maxn = 1e5 + 6;
const int sn = 20;
int fa[maxn][sn], deep[maxn], c[maxn];
vector<int> maze[maxn];
vector<int> data[maxn][sn];
vector<int> adr[maxn];
void Init() {
  for (int i = 0; i < maxn; i++)
    for (int j = 0; j < sn; j++) fa[i][j] = 1;
}
int buf[maxn];
void merge_data(const vector<int> &a, const vector<int> &b, vector<int> &c) {
  c.clear();
  int p = 0;
  for (const auto &it : a) buf[p++] = it;
  for (const auto &it : b) buf[p++] = it;
  sort(buf, buf + p);
  p = unique(buf, buf + p) - buf;
  int i = 0;
  while (c.size() < 10 && i < p) c.push_back(buf[i++]);
}
vector<int> merge_data(const vector<int> &a, const vector<int> &b) {
  vector<int> ret;
  int p = 0, i = 0;
  for (const auto &it : a) buf[p++] = it;
  for (const auto &it : b) buf[p++] = it;
  sort(buf, buf + p);
  p = unique(buf, buf + p) - buf;
  while (ret.size() < 10 && i < p) ret.push_back(buf[i++]);
  return ret;
}
void dfs(int cur, int dp) {
  deep[cur] = dp;
  for (int i = 0; i < maze[cur].size(); i++) {
    int son = maze[cur][i];
    if (fa[cur][0] != son) {
      fa[son][0] = cur;
      merge_data(adr[cur], adr[son], data[son][0]);
      for (int j = 1; j < sn; j++) {
        fa[son][j] = fa[fa[son][j - 1]][j - 1];
        merge_data(data[son][j - 1], data[fa[son][j - 1]][j - 1], data[son][j]);
      }
      dfs(son, dp + 1);
    }
  }
}
int jump(int x, int n) {
  for (int i = 0; i < 17; i++)
    if (n & (1 << i)) x = fa[x][i];
  return x;
}
int LCA(int a, int b) {
  a = jump(a, deep[a] - deep[b]);
  if (a == b) return a;
  for (int i = 16; i >= 0; i--) {
    if (fa[a][i] != fa[b][i]) {
      a = fa[a][i];
      b = fa[b][i];
    }
  }
  return fa[a][0];
}
vector<int> print;
void my_print(const vector<int> &v, int lim) {
  printf("%d", lim);
  for (int i = 0; i < lim; i++) printf(" %d", v[i]);
  printf("\n");
}
void answer(int u, int v, int a) {
  if (u == v) {
    int lim = min(a, int(adr[u].size()));
    my_print(adr[u], lim);
    return;
  }
  if (deep[u] < deep[v]) swap(u, v);
  int lca = LCA(u, v);
  if (u == lca) {
    print.clear();
    print = adr[u];
    int d = deep[v] - deep[u];
    for (int i = 0; i < sn; i++) {
      if (d & (1 << i)) {
        print = merge_data(data[v][i], print);
        v = fa[v][i];
      }
    }
    int lim = min(a, int(print.size()));
    my_print(print, lim);
  } else if (v == lca) {
    print.clear();
    print = adr[v];
    int d = deep[u] - deep[v];
    for (int i = 0; i < sn; i++) {
      if (d & (1 << i)) {
        print = merge_data(data[u][i], print);
        u = fa[u][i];
      }
    }
    int lim = min(a, int(print.size()));
    my_print(print, lim);
  } else {
    print.clear();
    print = adr[lca];
    print = merge_data(print, adr[u]);
    print = merge_data(print, adr[v]);
    int d = deep[u] - deep[v];
    for (int i = 0; i < sn; i++) {
      if (d & (1 << i)) {
        print = merge_data(data[u][i], print);
        u = fa[u][i];
      }
    }
    for (int i = sn - 1; i >= 0; i--) {
      if (fa[u][i] != fa[v][i]) {
        print = merge_data(print, data[u][i]);
        print = merge_data(print, data[v][i]);
        u = fa[u][i];
        v = fa[v][i];
      }
    }
    int lim = min(a, int(print.size()));
    my_print(print, lim);
  }
}
int main() {
  int n, m, q, i, j, k, x, y, a;
  scanf("%d%d%d", &n, &m, &q);
  for (i = 1; i < n; i++) {
    scanf("%d%d", &x, &y);
    maze[x].push_back(y);
    maze[y].push_back(x);
  }
  for (i = 1; i <= m; i++) {
    scanf("%d", &x);
    adr[x].push_back(i);
  }
  for (i = 1; i <= n; i++) {
    sort(adr[i].begin(), adr[i].end());
    while (adr[i].size() > 10) adr[i].pop_back();
  }
  Init();
  dfs(1, 0);
  while (q--) {
    scanf("%d%d%d", &x, &y, &a);
    answer(x, y, a);
  }
  return 0;
}
