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 = 100005;
struct tree {
  int fa, ch[2], rev, siz;
  int val[12], v_size;
  int t_val[12], t_val_size;
} t[MAXN];
int stk[MAXN], top, u[MAXN], v[MAXN], pos;
tree operator+(const tree &a, const tree &b) {
  tree c;
  c.t_val_size = 0;
  int p1 = 1, p2 = 1;
  while ((p1 <= a.t_val_size || p2 <= b.t_val_size) && c.t_val_size <= 10) {
    if (p1 <= a.t_val_size && p2 <= b.t_val_size) {
      if (a.t_val[p1] <= b.t_val[p2]) {
        c.t_val[++c.t_val_size] = a.t_val[p1++];
      } else {
        c.t_val[++c.t_val_size] = b.t_val[p2++];
      }
    } else if (p1 <= a.t_val_size) {
      c.t_val[++c.t_val_size] = a.t_val[p1++];
    } else {
      c.t_val[++c.t_val_size] = b.t_val[p2++];
    }
  }
  c.siz = a.siz + b.siz;
  return c;
}
void pushdown(int root) {
  if (t[root].rev) {
    t[root].rev = 0;
    swap(t[root].ch[0], t[root].ch[1]);
    t[t[root].ch[0]].rev ^= 1;
    t[t[root].ch[1]].rev ^= 1;
  }
  return;
}
void update(int root) {
  tree temp;
  temp.siz = 1;
  for (int i = 1; i <= 10; ++i) {
    temp.val[i] = t[root].val[i];
    temp.t_val[i] = t[root].val[i];
  }
  temp.v_size = t[root].v_size;
  temp.t_val_size = t[root].v_size;
  if (t[root].ch[0]) {
    pushdown(t[root].ch[0]);
    temp = t[t[root].ch[0]] + temp;
  }
  if (t[root].ch[1]) {
    pushdown(t[root].ch[1]);
    temp = temp + t[t[root].ch[1]];
  }
  for (int i = 1; i <= 10; ++i) {
    t[root].t_val[i] = temp.t_val[i];
  }
  t[root].t_val_size = temp.t_val_size;
  t[root].siz = temp.siz;
  return;
}
bool isroot(int root) {
  return t[t[root].fa].ch[0] != root && t[t[root].fa].ch[1] != root;
}
void rot(int root) {
  int fa = t[root].fa;
  int gfa = t[fa].fa;
  int t1 = (root != t[fa].ch[0]);
  int t2 = (fa != t[gfa].ch[0]);
  int ch = t[root].ch[1 ^ t1];
  if (!isroot(fa)) t[gfa].ch[0 ^ t2] = root;
  t[ch].fa = fa;
  t[root].fa = gfa;
  t[root].ch[1 ^ t1] = fa;
  t[fa].fa = root;
  t[fa].ch[0 ^ t1] = ch;
  update(fa);
  return;
}
void splay(int root) {
  stk[++top] = root;
  for (int i = root; !isroot(i); i = t[i].fa) {
    stk[++top] = t[i].fa;
  }
  while (top) {
    pushdown(stk[top--]);
  }
  while (!isroot(root)) {
    int fa = t[root].fa;
    int gfa = t[fa].fa;
    if (!isroot(fa))
      root == t[fa].ch[0] ^ fa == t[gfa].ch[0] ? rot(root) : rot(fa);
    rot(root);
  }
  update(root);
  return;
}
int access(int root) {
  int temp = 0;
  while (root) {
    splay(root);
    t[root].ch[1] = temp;
    temp = root;
    root = t[root].fa;
  }
  return temp;
}
void makeroot(int root) {
  access(root);
  splay(root);
  t[root].rev ^= 1;
}
void link(int root1, int root2) {
  makeroot(root1);
  t[root1].fa = root2;
}
void cut(int root1, int root2) {
  makeroot(root1);
  access(root2);
  splay(root2);
  t[root2].ch[0] = t[root1].fa = 0;
}
int lca(int root1, int root2, int root = 0) {
  if (root) makeroot(root);
  access(root1);
  return access(root2);
}
int findroot(int root) {
  access(root);
  splay(root);
  int temp = root;
  while (t[temp].ch[0]) temp = t[temp].ch[0];
  return temp;
}
int T, n, m, q, x, y, k;
int main() {
  scanf("%d %d %d", &n, &m, &q);
  for (int i = 1; i < n; ++i) {
    scanf("%d %d", &u[i], &v[i]);
  }
  for (int i = 1; i <= m; ++i) {
    scanf("%d", &pos);
    if (t[pos].v_size <= 10) {
      t[pos].val[++t[pos].v_size] = i;
      t[pos].t_val[++t[pos].t_val_size] = i;
    }
  }
  for (int i = 1; i <= n; ++i) {
    t[i].siz = 1;
  }
  for (int i = 1; i < n; ++i) {
    link(u[i], v[i]);
  }
  while (q--) {
    scanf("%d %d %d", &x, &y, &k);
    makeroot(x);
    access(y);
    splay(y);
    update(y);
    k = min(k, t[y].t_val_size);
    printf("%d", k);
    for (int i = 1; i <= k; ++i) {
      printf(" %d", t[y].t_val[i]);
    }
    printf("\n");
  }
  return 0;
}
