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;
inline bool read(int &n) {
  n = 0;
  register bool neg = false;
  register char c = getchar_unlocked();
  if (c == EOF) {
    n = -1;
    return false;
  }
  while (!('0' <= c && c <= '9')) {
    if (c == '-') neg = true;
    c = getchar_unlocked();
  }
  while ('0' <= c && c <= '9') {
    n = n * 10 + c - '0';
    c = getchar_unlocked();
  }
  n = (neg ? (-n) : (n));
  return true;
}
inline void writeInt(int n) {
  register int idx = 20;
  if (n < 0) putchar_unlocked('-');
  n = labs(n);
  char out[21];
  out[20] = ' ';
  do {
    idx--;
    out[idx] = n % 10 + '0';
    n /= 10;
  } while (n);
  do {
    putchar_unlocked(out[idx++]);
  } while (out[idx] != ' ');
}
struct tri {
  int para, idx;
  tri(int para = 0, int idx = 0) : para(para), idx(idx) {}
};
vector<int> grafo[500000];
vector<int> caras[500000];
int depth[500000], parent[500000], segtsz[500000];
int chain[500000], chainpos[500000], chainleader[500000];
int idx[500000];
int vet[500000], w;
vector<int> segt[(1 << 17) + 10];
int cur_chain, pos;
inline void combine(vector<int> &a, vector<int> &b, vector<int> &ans) {
  vector<int> ret;
  merge(a.begin(), a.end(), b.begin(), b.end(), back_inserter(ret));
  int tam = min((int)ret.size(), 10);
  ans.clear();
  for (int i = 0; i < tam; i++) ans.push_back(ret[i]);
}
void explore(int u) {
  int v;
  segtsz[u] = 1;
  for (size_t i = 0, sz = grafo[u].size(); i < sz; ++i) {
    v = grafo[u][i];
    if (parent[v] == -1) {
      parent[v] = u;
      depth[v] = depth[u] + 1;
      explore(v);
      segtsz[u] += segtsz[v];
    }
  }
}
void decompose(int u, bool light = true) {
  if (light) {
    ++cur_chain;
    chainleader[cur_chain] = u;
  }
  chain[u] = cur_chain;
  chainpos[u] = pos++;
  idx[pos - 1] = u - 1;
  int v, ind = -1, mx = -1;
  for (size_t i = 0, sz = grafo[u].size(); i < sz; ++i) {
    v = grafo[u][i];
    if ((parent[v] == u) && ((mx == -1) || (segtsz[mx] < segtsz[v])))
      mx = v, ind = i;
  }
  if (mx != -1) {
    decompose(mx, false);
  }
  for (size_t i = 0, sz = grafo[u].size(); i < sz; ++i) {
    v = grafo[u][i];
    if ((parent[v] == u) && (v != mx)) {
      decompose(v);
    }
  }
}
void build(int no, int lo, int hi) {
  if (lo == hi) {
    for (int i = 0; i < min(10, int(caras[idx[lo]].size())); i++) {
      segt[no].push_back(caras[idx[lo]][i]);
    }
  } else {
    int mid = (lo + hi) >> 1;
    int x = (no << 1) + 1;
    int y = x + 1;
    build(x, lo, mid);
    build(y, mid + 1, hi);
    combine(segt[x], segt[y], segt[no]);
  }
}
int n;
vector<int> resp;
void query(int node, int lo, int hi, int from, int to) {
  if (from <= lo && hi <= to) {
    combine(segt[node], resp, resp);
    return;
  }
  int ls = (node << 1) + 1;
  int rs = ls + 1;
  int mid = (lo + hi) >> 1;
  if (mid >= from) query(ls, lo, mid, from, to);
  if (mid + 1 <= to) query(rs, mid + 1, hi, from, to);
}
void query(int u, int v) {
  int from, to, folha = 1;
  while (chain[v] != chain[u]) {
    from = chainpos[chainleader[chain[v]]];
    to = chainpos[v];
    folha = 0;
    query(0, 0, pos, from, to);
    v = parent[chainleader[chain[v]]];
  }
  from = chainpos[u] + 1;
  to = chainpos[v];
  if (to >= from) query(0, 0, pos, from, to);
}
int lca(int u, int v) {
  while (chain[u] != chain[v]) {
    if (depth[chainleader[chain[u]]] < depth[chainleader[chain[v]]]) {
      v = parent[chainleader[chain[v]]];
    } else {
      u = parent[chainleader[chain[u]]];
    }
  }
  if (depth[u] < depth[v]) return u;
  return v;
}
int main() {
  ios::sync_with_stdio(false);
  register int n, k, de, para, m, id, val, lca_ab, a, b;
  read(n);
  read(m);
  read(k);
  for (int i = 0; i < n - 1; i++) {
    read(de);
    read(para);
    grafo[de].push_back(para);
    grafo[para].push_back(de);
  }
  for (int i = 0; i <= n + 10; i++) parent[i] = -1;
  for (int i = 1; i <= m; i++) {
    read(val);
    caras[val - 1].push_back(i);
  }
  parent[1] = 0;
  depth[1] = 0;
  explore(1);
  cur_chain = -1, pos = 0;
  parent[1] = -1;
  decompose(1);
  pos++;
  build(0, 0, pos);
  while (k--) {
    read(a);
    read(b);
    read(w);
    resp.clear();
    if (a == b) {
      query(0, 0, pos, chainpos[a], chainpos[a]);
      int tot = resp.size();
      writeInt(min(w, tot));
      if (min(w, tot)) putchar_unlocked(' ');
      for (int i = 0; i < min(w, tot); i++) {
        if (i) putchar_unlocked(' ');
        writeInt(resp[i]);
      }
      putchar_unlocked('\n');
    } else {
      lca_ab = lca(a, b);
      query(lca_ab, a);
      query(0, 0, pos, chainpos[lca_ab], chainpos[lca_ab]);
      query(lca_ab, b);
      int tot = resp.size();
      writeInt(min(w, tot));
      if (min(w, tot)) putchar_unlocked(' ');
      for (int i = 0; i < min(w, tot); i++) {
        if (i) putchar_unlocked(' ');
        writeInt(resp[i]);
      }
      putchar_unlocked('\n');
    }
  }
  return 0;
}
