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 dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
const long long linf = 4000000000000000000LL;
const int inf = 1000000007;
const long double pi = 3.1415926535;
long long maximum(long long x, long long y) {
  if (x > y) return x;
  return y;
}
long long minimum(long long x, long long y) {
  if (x < y) return x;
  return y;
}
void pv(vector<int> a) {
  for (auto& x : a) cout << x << " ";
  cout << '\n';
}
void pv(vector<long long> a) {
  for (auto& x : a) cout << x << " ";
  cout << '\n';
}
void pv(vector<vector<int>> a) {
  for (int i = (0); i < (a.size()); ++i) {
    cout << i << '\n';
    pv(a[i]);
    cout << '\n';
  }
}
void pv(vector<vector<long long>> a) {
  for (int i = (0); i < (a.size()); ++i) {
    cout << i << '\n';
    pv(a[i]);
  }
  cout << '\n';
}
void pv(vector<string> a) {
  for (auto& x : a) cout << x << '\n';
  cout << '\n';
}
int modInverse(int a, int m) {
  int m0 = m;
  int y = 0, x = 1;
  if (m == 1) return 0;
  while (a > 1) {
    int q = a / m;
    int t = m;
    m = a % m, a = t;
    t = y;
    y = x - q * y;
    x = t;
  }
  if (x < 0) x += m0;
  return x;
}
long long power(long long x, long long y) {
  long long k = 1 << 30;
  long long z = 1;
  while (k != 0) {
    z *= z;
    z %= inf;
    if (y >= k) {
      z *= x;
      z %= inf;
      y -= k;
    }
    k >>= 1;
  }
  return z;
}
long double area(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
  return ((long long)x.second * y.first + (long long)y.second * z.first +
          (long long)z.second * x.first - (long long)x.first * y.second -
          (long long)y.first * z.second - (long long)z.first * x.second) /
         2.0;
}
bool clockwise(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
  return area(x, y, z) > 0;
}
struct point {
  long double x, y;
};
long double area(point x, point y, point z) {
  return (x.y * y.x + y.y * z.x + z.y * x.x - x.x * y.y - y.x * z.y -
          z.x * x.y) /
         2.0;
}
bool clockwise(point x, point y, point z) { return area(x, y, z) > 0; }
int gcd(int a, int b) {
  if (a > b) swap(a, b);
  if (a == 0) return b;
  return gcd(a, b % a);
}
int popcount(int a) {
  int count = 0;
  while (a) {
    count += (a & 1);
    a >>= 1;
  }
  return count;
}
struct custom_hash {
  static uint64_t splitmix64(uint64_t x) {
    x += 0x9e3779b97f4a7c15;
    x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
    x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
    return x ^ (x >> 31);
  }
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    return splitmix64(x + FIXED_RANDOM);
  }
};
struct custom_hash_fast {
  size_t operator()(uint64_t x) const {
    static const uint64_t FIXED_RANDOM =
        chrono::steady_clock::now().time_since_epoch().count();
    x ^= FIXED_RANDOM;
    return x ^ (x >> 16);
  }
};
long long choose(long long n, long long r) {
  long long p = 1, k = 1;
  if (n - r < r) r = n - r;
  if (r != 0) {
    while (r) {
      p *= n;
      k *= r;
      long long m = gcd(p, k);
      p /= m;
      k /= m;
      n--;
      r--;
    }
  } else
    p = 1;
  return p;
}
void setIO(string second) {
  ios_base::sync_with_stdio(0);
  cin.tie(0);
}
int n, m, q;
vector<vector<int>> adj;
struct node {
  int depth, tin, tout, parent;
  vector<int> val;
};
int timenow;
vector<node> tree;
void dfs(int i, int p) {
  tree[i].tin = timenow++;
  tree[i].parent = p;
  for (auto& x : adj[i]) {
    if (x != p) {
      tree[x].depth = tree[i].depth + 1;
      dfs(x, i);
    }
  }
  tree[i].tout = timenow++;
}
vector<vector<int>> jump;
bool is_ancestor(int anc, int node) {
  return tree[anc].tin <= tree[node].tin && tree[anc].tout >= tree[node].tout;
}
int LCA(int x, int y) {
  if (tree[x].depth > tree[y].depth) swap(x, y);
  if (is_ancestor(x, y)) return x;
  int j = 16;
  int next;
  while (!is_ancestor(tree[x].parent, y)) {
    next = jump[x][j];
    if (next == -1 || is_ancestor(next, y)) {
      j--;
    } else {
      x = next;
    }
  }
  return tree[x].parent;
}
vector<vector<vector<int>>> jump1;
vector<int> merge(vector<int> a, vector<int> b) {
  vector<int> ans;
  int i = 0, j = 0;
  while (i != a.size() && j != b.size()) {
    if (i == a.size()) {
      ans.push_back(b[j++]);
    } else if (j == b.size()) {
      ans.push_back(a[i++]);
    } else {
      if (a[i] > b[j]) {
        ans.push_back(b[j++]);
      } else {
        ans.push_back(a[i++]);
      }
    }
  }
  ans.resize(10);
  return ans;
}
int get(int i, int dist) {
  int total = 17;
  while (total + 1) {
    if (dist & (1 << total)) {
      i = jump[i][total];
    }
    total--;
  }
  return i;
}
vector<int> solve(int i, int lca) {
  int dist = tree[i].depth - tree[lca].depth + 1;
  vector<int> ans(10, inf);
  int curr = 17, pos = i;
  while (curr + 1) {
    if (dist & (1 << curr)) {
      ans = merge(ans, jump1[pos][curr]);
      pos = jump[pos][curr];
    }
    curr--;
  }
  return ans;
}
int main() {
  setIO("gates");
  cin >> n >> m >> q;
  adj.resize(n);
  for (int i = (0); i < (n - 1); ++i) {
    int a, b;
    cin >> a >> b;
    adj[--a].push_back(--b);
    adj[b].push_back(a);
  }
  tree.resize(n);
  dfs(0, -1);
  int log = 17;
  jump.resize(n);
  for (int i = (0); i < (n); ++i) jump[i].resize(log);
  for (int i = (0); i < (n); ++i) jump[i][0] = tree[i].parent;
  for (int i = (0); i < (log - 1); ++i)
    for (int j = (0); j < (n); ++j) {
      int a = jump[j][i];
      if (a != -1)
        jump[j][i + 1] = jump[a][i];
      else
        jump[j][i + 1] = -1;
    }
  for (int i = (0); i < (m); ++i) {
    int a;
    cin >> a;
    if (tree[--a].val.size() < 10) tree[a].val.push_back(i + 1);
  }
  for (int i = (0); i < (n); ++i) tree[i].val.resize(10, inf);
  jump1.resize(n, vector<vector<int>>(log, vector<int>(10, inf)));
  for (int i = (0); i < (n); ++i) jump1[i][0] = tree[i].val;
  for (int i = (0); i < (log - 1); ++i) {
    for (int j = (0); j < (n); ++j) {
      if (tree[j].depth + 1 >= (1 << i + 1)) {
        jump1[j][i + 1] = merge(jump1[j][i], jump1[jump[j][i]][i]);
      }
    }
  }
  for (int i = (0); i < (q); ++i) {
    int a, b, c;
    cin >> a >> b >> c;
    a--;
    b--;
    if (tree[a].depth > tree[b].depth) swap(a, b);
    int lca = LCA(a, b);
    vector<int> t(10, inf);
    if (lca != a) {
      t = merge(t, solve(a, get(a, tree[a].depth - tree[lca].depth - 1)));
      t = merge(t, solve(b, lca));
    } else {
      t = merge(t, solve(b, lca));
    }
    while (int(t.size()) && t.back() == inf) t.pop_back();
    cout << min(int(t.size()), c) << " ";
    for (int j = (0); j < (min(int(t.size()), c)); ++j) cout << t[j] << " ";
    cout << '\n';
  }
}