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

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

    static class TaskAcmp {
        ArrayList<ArrayList<Integer>> g = new ArrayList<>();
        ArrayList<int[]> citizens = new ArrayList<>();
        int[] added;
        int[][] pred;
        boolean[] used;
        int[] path;
        int[] buf = new int[10];
        int[] store = new int[10];
        int[] logs;
        Node[] nodes;
        Node[] tree;
        int[] open;
        int[][][] top;
        boolean[] set;
        int times = 0;

        public void solve(int testNumber, Reader in, PrintWriter out) {
            int n, m, q;
            n = in.ni();
            m = in.ni();
            q = in.ni();
            for (int i = 0; i < n; i++) {
                g.add(new ArrayList<>());
                int[] arr = new int[10];
                Arrays.fill(arr, Integer.MAX_VALUE);
                citizens.add(arr);
            }
            pred = new int[n][18];
            added = new int[n];
            used = new boolean[n];
            path = new int[n];
            logs = new int[n];
            nodes = new Node[n];
            open = new int[n];
            tree = new Node[2 * n - 1];
            top = new int[n][18][10];
            set = new boolean[m];
            for (int i = 0; i < n; i++) {
                nodes[i] = new Node(i, 0);
            }
            for (int i = 1, pow = 0; i < n; i++) {
                if ((1 << (pow + 1)) <= i) {
                    ++pow;
                }
                logs[i] = pow;
            }
            for (int i = 0; i < n - 1; i++) {
                int u, v;
                u = in.ni();
                v = in.ni();
                g.get(u - 1).add(v - 1);
                g.get(v - 1).add(u - 1);
            }
            for (int i = 0; i < m; i++) {
                int c = in.ni() - 1;
                if (added[c] >= 10) {
                    continue;
                }
                citizens.get(c)[added[c]] = i;
                ++added[c];
            }
            for (int i = 0; i < n; i++) {
                Arrays.sort(citizens.get(i));
            }
            dfs(0, 0);
            Arrays.fill(used, false);
            dfs1(0, 0);
            SegmentTree st = new SegmentTree(tree);
            int v, u, a, lca, cnt;
            for (int i = 0; i < q; i++) {
                v = in.ni() - 1;
                u = in.ni() - 1;
                a = in.ni();
                cnt = 0;
                lca = st.get(0, st.leafs - 1, Math.min(open[v], open[u]), Math.max(open[v], open[u]), 0).u;
                findTop10(u, v, lca);
                for (int j = 0; j < 10; j++) {
                    if (store[j] == Integer.MAX_VALUE) {
                        break;
                    }
                    ++cnt;
                }
                out.print(Math.min(a, cnt) + " ");
                for (int j = 0; j < Math.min(a, cnt); j++) {
                    out.print(store[j] + 1 + " ");
                }
                out.println();
            }
        }

        public void dfs(int u, int curH) {
            used[u] = true;
            nodes[u].h = curH;
            tree[times++] = nodes[u];
            open[u] = times - 1;
            int pow = 0;
            int dist = 1;
            path[curH] = u;
            while (dist <= curH) {
                pred[u][pow] = path[curH - dist];
                dist *= 2;
                ++pow;
            }
            for (int v : g.get(u)) {
                if (!used[v]) {
                    dfs(v, curH + 1);
                    tree[times++] = nodes[u];
                }
            }
        }

        public void dfs1(int u, int curH) {
            used[u] = true;
            path[curH] = u;
            int dist, pow;
            dist = 1;
            pow = 0;
            while (dist <= curH) {
                findTop10(path[curH - 1], path[curH - dist], path[curH - dist]);
                merge(citizens.get(u));
                System.arraycopy(store, 0, top[u][pow], 0, 10);
                dist *= 2;
                ++pow;
            }
            for (int v : g.get(u)) {
                if (!used[v]) {
                    dfs1(v, curH + 1);
                }
            }
        }

        public void findTop10(int u, int v, int lca) {
            Arrays.fill(store, Integer.MAX_VALUE);
            findTop10V(u, lca);
            findTop10V(v, lca);
        }

        public void findTop10V(int u, int lca) {
            int dist = nodes[u].h - nodes[lca].h;
            while (dist != 0) {
                merge(top[u][logs[dist]]);
                u = pred[u][logs[dist]];
                dist -= (1 << logs[dist]);
            }
            merge(citizens.get(u));
        }

        public void merge(int[] list) {
            Arrays.fill(buf, Integer.MAX_VALUE);
            int left, right;
            left = 0;
            right = 0;
            for (int i = 0; i < 10; i++) {
                if (store[i] != Integer.MAX_VALUE) {
                    set[store[i]] = true;
                }
            }
            for (int i = 0; i < 10; ) {
                if (right >= 10) {
                    for (; i < 10 && left < 10; i++, left++) {
                        buf[i] = store[left];
                    }
                    break;
                }
                if (left >= 10) {
                    for (; i < 10 && right < 10; ) {
                        if (list[right] == Integer.MAX_VALUE) {
                            break;
                        }
                        if (!set[list[right]]) {
                            buf[i] = list[right];
                            ++i;
                        }
                        ++right;
                    }
                    break;
                }
                if (list[right] != Integer.MAX_VALUE && set[list[right]]) {
                    ++right;
                    continue;
                }
                if (store[left] < list[right]) {
                    buf[i] = store[left];
                    ++left;
                } else {
                    buf[i] = list[right];
                    ++right;
                }
                ++i;
            }
            for (int i = 0; i < 10; i++) {
                if (store[i] != Integer.MAX_VALUE) {
                    set[store[i]] = false;
                }
            }
            System.arraycopy(buf, 0, store, 0, 10);
        }

        class Node {
            int u;
            int h;

            public Node(int u, int h) {
                this.u = u;
                this.h = h;
            }

        }

        class SegmentTree {
            Node[] b;
            int leafs;
            Node fake = new Node(0, Integer.MAX_VALUE);

            public SegmentTree(Node[] a) {
                int log = 1;
                while (log < a.length) {
                    log *= 2;
                }
                b = new Node[2 * log - 1];
                leafs = log;
                for (int i = log - 1; i < log - 1 + a.length; i++) {
                    b[i] = a[i - (log - 1)];
                }
                for (int i = log - 1 + a.length; i < b.length; i++) {
                    b[i] = fake;
                }
                for (int i = log - 2; i >= 0; i--) {
                    if (b[2 * i + 1].h < b[2 * i + 2].h) {
                        b[i] = b[2 * i + 1];
                    } else {
                        b[i] = b[2 * i + 2];
                    }
                }
            }

            public Node get(int tl, int tr, int ql, int qr, int node) {
                if (ql > qr) {
                    return fake;
                }
                if (tl == ql && tr == qr) {
                    return b[node];
                }
                int mid = tl + (tr - tl) / 2;
                Node node1 = get(tl, mid, ql, Math.min(mid, qr), node * 2 + 1);
                Node node2 = get(mid + 1, tr, Math.max(mid + 1, ql), qr, node * 2 + 2);
                if (node1.h < node2.h) {
                    return node1;
                } else {
                    return node2;
                }
            }

        }

    }

    static class Reader {
        private BufferedReader in;
        private StringTokenizer st = new StringTokenizer("");
        private String delim = " ";

        public Reader(InputStream in) {
            this.in = new BufferedReader(new InputStreamReader(in));
        }

        public String next() {
            if (!st.hasMoreTokens()) {
                st = new StringTokenizer(rl());
            }
            return st.nextToken(delim);
        }

        public String rl() {
            try {
                return in.readLine();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }

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

    }
}

