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;
template <typename T>
struct segment_tree_persistent {
  const static T neutro = 0;
  struct node {
    node *left, *right;
    T val;
    node() : val(neutro), left(NULL), right(NULL) {}
    node(T val, node* left, node* right) : val(val), left(left), right(right) {}
    void extend(int l, int r) {
      if (left == NULL && l != r) {
        left = new node();
        right = new node();
      }
    }
  };
  int sz;
  vector<node*> versions;
  vector<int> parent;
  segment_tree_persistent(int sz) : sz(sz) {
    versions.reserve(1e5);
    parent.reserve(1e5);
    versions.push_back(new node());
    parent.push_back(-1);
  }
  T query(int ver, int l, int r) { return query(versions[ver], l, r, 1, sz); }
  int update(int ver, int _parent, int idx, T val) {
    versions.push_back(update(versions[ver], idx, 1, sz, val));
    parent.push_back(_parent);
    return versions.size() - 1;
  }
  int search(int ver_l, int ver_r, int ver_m, int k) {
    return search(versions[ver_l], versions[ver_r], versions[ver_m],
                  versions[parent[ver_m]], 1, sz, k);
  }
  T merge(T a, T b) { return a + b; }
  node* update(node* curr, int idx, int ini, int fin, T val) {
    if (ini > idx || fin < idx) return curr;
    if (ini == idx && ini == fin) return new node(val + curr->val, NULL, NULL);
    int mid = (ini + fin) >> 1;
    curr->extend(ini, fin);
    node* new_node = new node();
    new_node->left = update(curr->left, idx, ini, mid, val);
    new_node->right = update(curr->right, idx, mid + 1, fin, val);
    new_node->val = merge(new_node->left->val, new_node->right->val);
    return new_node;
  }
  T query(node* curr, int l, int r, int ini, int fin) {
    if (ini > r || fin < l) return neutro;
    if (l <= ini && fin <= r) return curr->val;
    int mid = (ini + fin) >> 1;
    curr->extend(ini, fin);
    return merge(query(curr->left, l, r, ini, mid),
                 query(curr->right, l, r, mid + 1, fin));
  }
  int search(node* curr_l, node* curr_r, node* curr_m, node* curr_mp, int ini,
             int fin, int k) {
    if (ini == fin) return ini;
    curr_l->extend(ini, fin);
    curr_r->extend(ini, fin);
    curr_m->extend(ini, fin);
    curr_mp->extend(ini, fin);
    int val = curr_r->left->val + curr_l->left->val - curr_m->left->val -
              curr_mp->left->val;
    int mid = (ini + fin) >> 1;
    if (val >= k)
      return search(curr_l->left, curr_r->left, curr_m->left, curr_mp->left,
                    ini, mid, k);
    return search(curr_l->right, curr_r->right, curr_m->right, curr_mp->right,
                  mid + 1, fin, k - val);
  }
};
const int MAXN = 1e5 + 5;
int n, m, q;
int ver[MAXN], ancestor[MAXN][20], level[MAXN];
vector<int> adj[MAXN], people[MAXN];
void dfs(int u, segment_tree_persistent<int>& st) {
  int p;
  p = ver[u] = ver[ancestor[u][0]];
  ver[u] = st.update(ver[ancestor[u][0]], p, 1, 0);
  for (auto i : people[u]) ver[u] = st.update(ver[u], p, i, 1);
  for (auto v : adj[u]) {
    if (v == ancestor[u][0]) continue;
    level[v] = level[u] + 1;
    ancestor[v][0] = u;
    dfs(v, st);
  }
}
void build(int root, segment_tree_persistent<int>& st) {
  memset(ancestor, -1, sizeof ancestor);
  ancestor[root][0] = root;
  dfs(root, st);
  for (int i = 1; (1 << i) <= n; i++) {
    for (int u = 1; u <= n; u++) {
      ancestor[u][i] = ancestor[ancestor[u][i - 1]][i - 1];
    }
  }
}
int lca(int u, int v) {
  if (level[u] < level[v]) swap(u, v);
  int lg;
  for (lg = 1; (1 << lg) <= level[u]; lg++)
    ;
  lg--;
  for (int i = lg; i >= 0; i--) {
    if (level[u] - (1 << i) >= level[v]) u = ancestor[u][i];
  }
  if (u == v) return u;
  for (int i = lg; i >= 0; i--) {
    if (ancestor[u][i] != -1 && ancestor[u][i] != ancestor[v][i]) {
      u = ancestor[u][i];
      v = ancestor[v][i];
    }
  }
  return ancestor[u][0];
}
int main() {
  cin >> n >> m >> q;
  segment_tree_persistent<int> st(m);
  for (int i = 0; i < n - 1; i++) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
    adj[v].push_back(u);
  }
  for (int i = 0; i < m; i++) {
    int c;
    cin >> c;
    people[c].push_back(i + 1);
  }
  build(1, st);
  for (int i = 0; i < q; i++) {
    int u, v, _lca, a;
    cin >> u >> v >> a;
    _lca = lca(u, v);
    int tot = st.query(ver[u], 1, m) + st.query(ver[v], 1, m) -
              st.query(ver[_lca], 1, m) - st.query(st.parent[ver[_lca]], 1, m);
    cout << min(tot, a) << ' ';
    for (int j = 1; j <= min(tot, a); j++) {
      int x = st.search(ver[u], ver[v], ver[_lca], j);
      cout << x << ' ';
    }
    cout << '\n';
  }
  return 0;
}