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 long long MOD = 1e9 + 7;
const long long INF = numeric_limits<long long>::max();
const long long NEGINF = numeric_limits<long long>::min();
template <typename T>
inline void readInt(T &n) {
  n = 0;
  int ch = getchar();
  int sign = 1;
  while (ch < '0' || ch > '9') {
    if (ch == '-') sign = -1;
    ch = getchar();
  }
  while (ch >= '0' && ch <= '9')
    n = (n << 3) + (n << 1) + ch - '0', ch = getchar();
  n = n * sign;
}
template <typename T>
inline void writeInt(T &n) {
  if (n < 0) putchar('-'), n *= -1;
  if (n == 0) {
    putchar('0');
    return;
  }
  stack<int> st;
  while (n) {
    st.push(n % 10);
    n /= 10;
  }
  while (!st.empty()) {
    putchar(st.top() + '0');
    st.pop();
  }
}
template <typename T>
void print(T t) {
  cout << t << " ";
}
template <typename T, typename... Args>
void print(T t, Args... args) {
  cout << t << " ";
  print(args...);
}
template <class T>
void print(vector<T> &list) {
  for (auto &x : list) cout << x << " ";
}
template <class T>
void read(vector<T> &list, long long n) {
  list.clear(), list.resize(n);
  for (auto &x : list) cin >> x;
}
long long p2[] = {1,
                  2,
                  4,
                  8,
                  16,
                  32,
                  64,
                  128,
                  256,
                  512,
                  1024,
                  2048,
                  4096,
                  8192,
                  16384,
                  32768,
                  65536,
                  131072,
                  262144,
                  524288,
                  1048576,
                  2097152,
                  4194304,
                  8388608,
                  16777216,
                  33554432,
                  67108864,
                  134217728,
                  268435456,
                  536870912,
                  1073741824,
                  2147483648,
                  4294967296,
                  8589934592,
                  17179869184,
                  34359738368,
                  68719476736,
                  137438953472,
                  274877906944,
                  549755813888,
                  1099511627776,
                  2199023255552,
                  4398046511104,
                  8796093022208,
                  17592186044416,
                  35184372088832,
                  70368744177664,
                  140737488355328,
                  281474976710656,
                  562949953421312,
                  1125899906842624,
                  2251799813685248,
                  4503599627370496,
                  9007199254740992,
                  18014398509481984,
                  36028797018963968,
                  72057594037927936,
                  144115188075855872,
                  288230376151711744,
                  576460752303423488,
                  1152921504606846976};
bool isPowerOfTwo(long long);
int len_of_number(long long);
int sum_of_digits(long long);
long long fast_exp(long long x, long long i);
long long fast_exp(long long x, long long i, long long mod);
long long modInverse(long long x, long long mod);
long long gcd(long long x, long long y);
vector<vector<int> > adjList;
int adjList_size;
void printGraph(int a, int b, vector<vector<int> > &graph) {
  for (int i = (a); i <= (b); i++) {
    print(i, ": ");
    for (auto &x : graph[i]) {
      print(x, ",");
    }
    cout << "\n";
  }
}
void getEdges(int n, int m, bool oneBased = true) {
  if (oneBased)
    adjList.resize(n + 1), adjList_size = n + 1;
  else
    adjList.resize(n), adjList_size = n;
  int a, b;
  for (auto &x : adjList) x.clear();
  for (int i = (1); i <= (m); i++) {
    scanf("%d", &a);
    scanf("%d", &b);
    adjList[a].push_back(b), adjList[b].push_back(a);
  }
}
vector<vector<int> > people;
int a;
const int MAXN = (1e5) + 11;
const int LOGN = 17;
int parent[MAXN][LOGN];
vector<int> numbers[MAXN][LOGN];
void printArr(vector<int> &a) {
  for (auto &x : a) writeInt(x), putchar(' ');
  putchar('\n');
}
vector<int> depth;
void dfs(int f, int g = 0) {
  for (auto &s : adjList[f]) {
    if (s != g) {
      depth[s] = 1 + depth[f];
      parent[s][0] = f;
      numbers[s][0].insert(numbers[s][0].end(), people[f].begin(),
                           people[f].end());
      sort(numbers[s][0].begin(), numbers[s][0].end());
      if (numbers[s][0].size() > 10) numbers[s][0].resize(10);
      for (int i = (1); i <= (LOGN - 1); i++) {
        parent[s][i] = parent[parent[s][i - 1]][i - 1];
        numbers[s][i].insert(numbers[s][i].end(), numbers[s][i - 1].begin(),
                             numbers[s][i - 1].end());
        numbers[s][i].insert(numbers[s][i].end(),
                             numbers[parent[s][i - 1]][i - 1].begin(),
                             numbers[parent[s][i - 1]][i - 1].end());
        sort(numbers[s][i].begin(), numbers[s][i].end());
        auto it = unique(numbers[s][i].begin(), numbers[s][i].end());
        numbers[s][i].resize(min(10, int(distance(numbers[s][i].begin(), it))));
      }
      dfs(s, f);
    }
  }
}
int LCA(int v, int u) {
  if (depth[v] < depth[u]) swap(v, u);
  for (int i = LOGN - 1; i >= 0; i--)
    if (parent[v][i] and depth[parent[v][i]] >= depth[u]) v = parent[v][i];
  if (v == u) return v;
  for (int i = LOGN - 1; i >= 0; i--)
    if (parent[v][i] - parent[u][i]) v = parent[v][i], u = parent[u][i];
  return parent[v][0];
}
vector<int> ans;
void getAns(int v, int p) {
  for (int i = 0; i < LOGN; i++) {
    if (p & p2[i]) {
      ans.insert(ans.end(), numbers[v][i].begin(), numbers[v][i].end());
      sort(ans.begin(), ans.end());
      auto it = unique(ans.begin(), ans.end());
      ans.resize(distance(ans.begin(), it));
      if ((int)ans.size() > a) ans.resize(a);
      v = parent[v][i];
    }
  }
}
void query(int u, int v, int a) {
  ans.clear();
  ans.insert(ans.begin(), people[u].begin(), people[u].end());
  if (u != v) ans.insert(ans.begin(), people[v].begin(), people[v].end());
  sort(ans.begin(), ans.end());
  if (ans.size() > a) ans.resize(a);
  int L = LCA(u, v);
  if (u != L) getAns(u, depth[u] - depth[L]);
  if (v != L) getAns(v, depth[v] - depth[L]);
  ans.resize(min((int)ans.size(), a));
  int Z = ans.size();
  printf("%d ", Z);
  for (auto &x : ans) printf("%d ", x);
  printf("\n");
}
inline void solve(long long _T) {
  int n, m, q, x, u, v;
  scanf("%d", &n);
  scanf("%d", &m);
  scanf("%d", &q);
  getEdges(n, n - 1);
  people.resize(n + 1);
  vector<int> peopleSize(n + 1, 0);
  for (int i = (1); i <= (m); i++) {
    scanf("%d", &x);
    if (peopleSize[x] < 10) {
      people[x].push_back(i);
      peopleSize[x]++;
      numbers[x][0].push_back(i);
    }
  }
  parent[1][0] = 0;
  depth.resize(n + 1, 0);
  dfs(1);
  while (q--) {
    scanf("%d", &u);
    scanf("%d", &v);
    scanf("%d", &a);
    query(u, v, a);
  }
}
int main() {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  long long test_cases;
  test_cases = 1;
  for (int T = (0); T <= (test_cases - 1); T++) {
    solve(T);
  }
  return 0;
}
bool isPowerOfTwo(long long x) { return (x != 0 && (x & (x - 1)) == 0); }
int len_of_number(long long n) {
  int len(0);
  while (n != 0) {
    ++len;
    n /= 10;
  }
  return len;
}
int sum_of_digits(long long n) {
  int sod = 0;
  while (n != 0) {
    sod += (n % 10);
    n /= 10;
  }
  return sod;
}
long long fast_exp(long long x, long long i) {
  long long ans = 1;
  while (i > 0) {
    if (i & 1) ans = (ans * x);
    i >>= 1;
    x = (x * x);
  }
  return ans;
}
long long fast_exp(long long x, long long i, long long mod) {
  long long ans = 1;
  while (i > 0) {
    if (i & 1) ans = (ans * x) % mod;
    i >>= 1;
    x = (x * x) % mod;
  }
  return ans;
}
long long modInverse(long long x, long long mod) {
  return fast_exp(x, mod - 2, mod);
}
long long gcd(long long x, long long y) {
  long long t;
  while (y != 0) {
    t = x % y;
    x = y;
    y = t;
  }
  return x;
}