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>
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.util.TreeSet;

public class Main {
    // int n = in.nextInt();
    // long a[] = new long[n];
    // for (int i = 0; i < n; i++) a[i] = in.nextInt();
    // Arrays.sort(a);

    // int n = in.nextInt(); int m = in.nextInt();
    // int a[][] = new int[n][m];
    // for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) a[i][j] = in.nextInt();

    // string s = in.next();


    public static final int N = 100000+5;
    public static int log = 1;
    public static int p[] = new int[N];
    public static long MOD = 1000000000 + 7;
    public static int tin[] = new int[N];
    public static int tout[] = new int[N];

    public static int lca[][] = new int[N][20];
    public static int mins[][][] = new int[N][20][11];
    public static int lives[][] = new int[N][11];
    public static int ll[] = new int[N];

    public static ArrayList<ArrayList<Integer>> adj = new ArrayList<ArrayList<Integer>>();
    public static int timer = 0;

    public static int[] merge(int a[], int b[]) {
        int c[] = new int[15];
        int count = 0;
        int i = 0;
        int j = 0;
        while (count < 10 && (a[i] != 0 || b[j] != 0)) {
            count++;
            if (a[i] == 0) {
                c[count - 1] = b[j]; j++;
            } else
            if (b[j] == 0) {
                c[count - 1] = a[i]; i++;
            } else
            if (a[i] != 0 && b[j] != 0) {
                if (a[i] < b[j]) {
                    c[count - 1] = a[i]; i++;
                } else {
                    c[count - 1] = b[j]; j++;
                }
            }
        }
        return c;
    }

    public static void setTimers(int t, int p) {
        timer++;
        tin[t] = timer;
        lca[t][0] = p;
        mins[t][0] = lives[t];
        for (int i = 1; i <= log; ++i) {
            lca[t][i] = lca[lca[t][i - 1]][i - 1];
            mins[t][i] = merge(mins[t][i - 1], mins[lca[t][i - 1]][i - 1]);
        }
        for (int to : adj.get(t)) {
            if (to != p) {
                setTimers(to, t);
            }
        }
        timer++;
        tout[t] = timer;
    }

    public static boolean isP(int a, int b) {
        if (a == 0) return true;
        return tin[a] <= tin[b] && tout[a] >= tout[b];
    }

    public static int lca(int a, int b) {
        if (isP(a, b))  return a;
        if (isP(b, a))  return b;
        for (int i = log; i >= 0; i--) {
            if (!isP(lca[a][i], b)) {
                a = lca[a][i];
            }
        }
        return lca[a][0];
    }

    public static int[] getPath(int a, int b) {
        if (a == b) return new int[15];
        int ans[] = new int[15];
        for (int i = log; i >= 0; --i) {
            if (!isP(lca[a][i], b)) {
                ans = merge(ans, mins[a][i]);
                a = lca[a][i];
            }
        }
        ans = merge(ans, mins[a][0]);
        return ans;
    }


    public static void main(String[] args) throws IOException {
        InputReader in = new InputReader(System.in);
        PrintWriter out = new PrintWriter(System.out);

        int n = in.nextInt();
        int m = in.nextInt();
        int q = in.nextInt();

        int pow = 1;
        while (pow <= n) {
            log++;
            pow *= 2;
        }

        for (int i = 0; i <= n; i++) {
            adj.add(new ArrayList<Integer>());
        }

        for (int i = 0; i < n - 1; i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            adj.get(u).add(v);
            adj.get(v).add(u);
        }
        for (int i = 1; i <= m; i++) {
            int c = in.nextInt();
            if (ll[c] < 10) {
                ll[c]++;
                lives[c][ll[c] - 1] = i;
            }
        }

        setTimers(1, 0);

        for (int i = 0; i < q; i++) {
            int u = in.nextInt();
            int v = in.nextInt();
            int a = in.nextInt();

            int lca = lca(u, v);

            int a1[] = getPath(u, lca);
            int a2[] = getPath(v, lca);
            int ans[] = merge(a1, a2);
            ans = merge(ans, lives[lca]);
            int ll = 0;
            while (ans[ll] != 0) {
                ll++;
            }
            int len = Math.min(ll, a);
            out.print(len);
            for (int ii = 0; ii < len; ii++) {
                out.print(" " + ans[ii]);
            }
            out.println();
        }

        out.close();
    }
}
class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream));
        tokenizer = null;
    }
    public String nextLine() throws IOException {
        return reader.readLine();
    }
    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 double nextDouble() {
        return Double.parseDouble(next());
    }

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

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