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 JAVA):

Solution:
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));
        }
    }
}