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];
        Arrays.sort(tmp);
        int pt = 0;
        Arrays.fill(c, inf);
        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();
        E = new ArrayList[n];
        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];
        Arrays.fill(res, inf);
        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);
            Arrays.fill(res, inf);
            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++;
            cnt = Math.min(cnt, c);
            writer.printf("%d", cnt);
            for (int j = 0; j < cnt; j++)
                writer.printf(" %d", res[j] + 1);
            writer.printf("\n");
        }
    }


    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }
    }

    static class OutputWriter {
        public PrintWriter writer;

        OutputWriter(OutputStream stream) {
            writer = new PrintWriter(stream);
        }

        public void printf(String format, Object... args) {
            writer.print(String.format(Locale.ENGLISH, format, args));
        }
    }
}