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.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.List;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        FastInputReader in = new FastInputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        TaskE solver = new TaskE();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskE {
        List<Integer>[] trees;
        int[][] people;
        int[][] par;
        int[][][] smallest;
        int[] depth;

        private void init(int n) {
            smallest = new int[n][20][10];
            depth = new int[n];
            trees = new List[n];
            people = new int[n][10];
            par = new int[n][20];
            for (int i = 0; i < n; i++) {
                trees[i] = new ArrayList<>();
                Arrays.fill(people[i], Integer.MAX_VALUE);
                for (int j = 0; j < 20; j++) {
                    par[i][j] = -1;
                    Arrays.fill(smallest[i][j], Integer.MAX_VALUE);
                }
            }
        }

        public void solve(int testNumber, FastInputReader in, PrintWriter out) {
            int n = in.nextInt();
            int m = in.nextInt();
            int q = in.nextInt();
            init(n);

            for (int i = 0; i < n - 1; i++) {
                int u = in.nextInt() - 1;
                int v = in.nextInt() - 1;
                trees[u].add(v);
                trees[v].add(u);
            }
            int[] index = new int[n];
            for (int i = 0; i < m; i++) {
                int c = in.nextInt() - 1;
                if (index[c] < 10) {
                    people[c][index[c]++] = i + 1;
                } else {
                    Arrays.sort(people[c]);
                    if (people[c][9] > i + 1) {
                        people[c][9] = i + 1;
                    }
                }
            }
            preProcess(n);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < q; i++) {
                int from = in.nextInt() - 1;
                int to = in.nextInt() - 1;
                int a = in.nextInt();

                int[] ans = LCA(from, to);

                int len = 10;
                for (int j = 0; j < ans.length; j++) {
                    if (ans[j] == Integer.MAX_VALUE) {
                        len = j;
                        break;
                    }
                }
                int sz = Math.min(a, len);
                sb.append(sz);
                for (int j = 0; j < sz; j++) {
                    sb.append(" " + ans[j]);
                }
                sb.append("\n");
            }
            out.print(sb);
        }

        private int[] merge(int[] a, int[] b) {
            int aLen = a.length;
            int bLen = b.length;
            int[] tmp = new int[aLen + bLen];
            for (int i = 0; i < aLen; i++) {
                tmp[i] = a[i];
            }
            for (int i = 0; i < bLen; i++) {
                tmp[i + aLen] = b[i];
            }
            Arrays.sort(tmp);
            int n = Math.min(10, aLen + bLen);
            int[] res = new int[n];
            for (int i = 0; i < n; i++) {
                res[i] = tmp[i];
            }
            return res;
        }

        private int[] LCA(int u, int v) {
            int[] ans = new int[10];
            Arrays.fill(ans, Integer.MAX_VALUE);
            if (depth[u] < depth[v]) {
                int tmp = u;
                u = v;
                v = tmp;
            }
            if (u == v) {
                ans = merge(ans, people[u]);
                return ans;
            }
            int V = v;
            int U = u;
            int log = 0;
            while (1 << log <= depth[u]) log++;
            log--;

            for (int i = log; i >= 0; i--) {
                if (depth[u] - (1 << i) >= depth[v]) {
                    ans = merge(ans, smallest[u][i]);
                    u = par[u][i];
                }
            }

            if (u == v) {
                ans = merge(ans, people[U]);
                return ans;
            }
            ans = merge(ans, people[U]);
            ans = merge(ans, people[V]);
            for (int i = log; i >= 0; i--) {
                if (par[u][i] != -1 && par[u][i] != par[v][i]) {
                    ans = merge(ans, smallest[u][i]);
                    ans = merge(ans, smallest[v][i]);
                    u = par[u][i];
                    v = par[v][i];
                }
            }
            ans = merge(ans, smallest[u][0]);
            return ans;
        }

        private void preProcess(int n) {
            dfs(0, -1);
            for (int j = 1; 1 << j < n; j++) {
                for (int i = 0; i < n; i++) {
                    if (par[i][j - 1] != -1) {
                        par[i][j] = par[par[i][j - 1]][j - 1];
                        smallest[i][j] = merge(smallest[i][j - 1], smallest[par[i][j - 1]][j - 1]);
                    }
                }
            }
        }

        private void dfs(int u, int p) {
            par[u][0] = p;
            // smallest[u][0] = people[u];
            if (p != -1) {
                depth[u] = depth[p] + 1;
                smallest[u][0] = people[p];
            }
            for (int v : trees[u]) {
                if (v != p) {
                    dfs(v, u);
                }
            }
        }

    }

    static class FastInputReader {
        static InputStream is;
        static private byte[] buffer;
        static private int lenbuf;
        static private int ptrbuf;

        public FastInputReader(InputStream stream) {
            is = stream;
            buffer = new byte[1024];
            lenbuf = 0;
            ptrbuf = 0;
        }

        private int readByte() {
            if (lenbuf == -1)
                throw new InputMismatchException();
            if (ptrbuf >= lenbuf) {
                ptrbuf = 0;
                try {
                    lenbuf = is.read(buffer);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (lenbuf <= 0)
                    return -1;
            }
            return buffer[ptrbuf++];
        }

        public int nextInt() {
            int num = 0, b;
            boolean minus = false;
            while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
                ;
            if (b == '-') {
                minus = true;
                b = readByte();
            }

            while (true) {
                if (b >= '0' && b <= '9') {
                    num = num * 10 + (b - '0');
                } else {
                    return minus ? -num : num;
                }
                b = readByte();
            }
        }

    }
}