import java.io.*;
import java.util.*;
public class TaskC_slow {
private final InputReader reader;
private final OutputWriter writer;
public TaskC_slow(InputReader reader, OutputWriter writer) {
this.reader = reader;
this.writer = writer;
}
public static void main
(String[] args
) { InputReader reader
= new InputReader
(System.
in); OutputWriter writer
= new OutputWriter
(System.
out); new TaskC_slow(reader, writer).run();
writer.writer.flush();
}
List<Integer>[] E;
int lgn;
final int K = 10;
final int inf = 1000 * 1000 * 1000 + 42;
int[][][] upVal;
int[][] up;
int[] tmp;
void merge(int[] a, int[] b, int[] c) {
for (int i = 0; i < a.length; i++)
tmp[i] = a[i];
for (int i = 0; i < b.length; i++)
tmp[i + a.length] = b[i];
int pt = 0;
for (int i = 0; i < tmp.length && pt < c.length; i++)
if (pt == 0 || tmp[i] != c[pt - 1])
c[pt++] = tmp[i];
}
int[] D;
void DFS(int x, int p) {
up[0][x] = p;
D[x] = D[p] + 1;
for (int l = 1; l <= lgn; l++) {
up[l][x] = up[l - 1][up[l - 1][x]];
merge(upVal[l - 1][x], upVal[l - 1][up[l - 1][x]], upVal[l][x]);
}
for (int i = 0; i < E[x].size(); i++) {
int y = E[x].get(i);
if (y == p) {
E[x].remove(i);
--i;
continue;
}
DFS(y, x);
}
}
int lca(int a, int b) {
if (D[a] > D[b]) {
int t = a;
a = b;
b = t;
}
for (int l = lgn; l >= 0; l--)
if (D[b] - D[a] >= (1 << l))
b = up[l][b];
if (a == b)
return a;
for (int l = lgn; l >= 0; l--)
if (up[l][a] != up[l][b]) {
a = up[l][a];
b = up[l][b];
}
a = up[0][a];
return a;
}
public void run() {
int n = reader.nextInt();
int m = reader.nextInt();
int q = reader.nextInt();
for (int i = 0; i < n; i++)
E[i] = new ArrayList<Integer>();
for (int i = 0; i < n - 1; i++) {
int a = reader.nextInt() - 1;
int b = reader.nextInt() - 1;
E[a].add(b);
E[b].add(a);
}
lgn = 0;
while ((1 << (lgn + 1)) <= n)
lgn++;
upVal = new int[lgn + 1][n][K];
for (int x = 0; x < n; x++)
Arrays.
fill(upVal
[0][x
], inf
); up = new int[lgn + 1][n];
tmp = new int[2 * K];
D = new int[n];
int[] res = new int[K];
for (int i = 0; i < m; i++) {
int t = reader.nextInt() - 1;
res[0] = i;
merge(res, upVal[0][t], upVal[0][t]);
}
DFS(0, 0);
for (int i = 0; i < q; i++) {
int a = reader.nextInt() - 1;
int b = reader.nextInt() - 1;
int c = reader.nextInt();
int x = lca(a, b);
for (int l = lgn; l >= 0; l--) {
if (D[a] - (1 << l) >= D[x] - 1) {
merge(upVal[l][a], res, res);
a = up[l][a];
}
if (D[b] - (1 << l) >= D[x] - 1) {
merge(upVal[l][b], res, res);
b = up[l][b];
}
}
int cnt = 0;
while (cnt < res.length && res[cnt] != inf)
cnt++;
writer.printf("%d", cnt);
for (int j = 0; j < cnt; j++)
writer.printf(" %d", res[j] + 1);
writer.printf("\n");
}
}
static class InputReader {
tokenizer = null;
}
while (tokenizer == null || !tokenizer.hasMoreTokens()) {
try {
}
}
return tokenizer.nextToken();
}
public int nextInt() {
}
public double nextDouble() {
return Double.
parseDouble(next
()); }
public long nextLong() {
return Long.
parseLong(next
()); }
}
static class OutputWriter {
}
}
}
}