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

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

    static class TaskC_CF_XXX {
        Graph g;
        int[][][] onPath;
        public int HEIGHT;
        int[][] parent;
        DFSOrder order;

        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int countPeople = in.nextInt();
            int countQueries = in.nextInt();
            g = new Graph();
            g.initGraph(n, n - 1);

            for (int i = 0; i < n - 1; ++i) {
                int a = in.nextInt() - 1;
                int b = in.nextInt() - 1;
                g.addEdge(a, b);
            }
            parent = Parent.getLevelParents(g, 0);
            int maxLevel = 1;
            while ((1 << maxLevel) <= g.nVertex) {
                ++maxLevel;
            }
            HEIGHT = maxLevel;
            onPath = new int[HEIGHT][n][0];
            order = new DFSOrder(g, 0, parent[0]);

            for (int i = 0; i < countPeople; ++i) {
                int city = in.nextInt() - 1;
                int[] to = new int[]{i};
                onPath[0][city] = merge(onPath[0][city], to, 10);
            }
            dfs(0, -1);
            for (int i = 0; i < countQueries; ++i) {
                int a = in.nextInt() - 1;
                int b = in.nextInt() - 1;
                int am = in.nextInt();
                int l = lca(a, b);
                int[] a1 = get(a, l, am);
                int[] a2 = get(b, l, am);
                int[] res = merge(a1, a2, am);
                res = merge(res, onPath[0][l], am);
                out.print(res.length);
                for (int x : res) {
                    out.print(" " + (x + 1));
                }
                out.println();
            }
        }

        private int lca(int a, int b) {
            if (order.isChild(a, b)) return b;
            if (order.isChild(b, a)) return a;
            for (int h = HEIGHT - 1; h >= 0; --h) {
                if (parent[h][a] == -1) continue;
                if (order.isChild(b, parent[h][a])) continue;
                a = parent[h][a];
            }
            return parent[0][a];
        }

        private void dfs(int v, int p) {
            for (int j = 1; j < HEIGHT; ++j) {
                if (parent[j - 1][v] != -1) {
                    onPath[j][v] = merge(onPath[j - 1][v], onPath[j - 1][parent[j - 1][v]], 10);
                }
            }
            for (int ei = g.first[v]; ei != -1; ei = g.next[ei]) {
                int to = g.to[ei];
                if (to == p) continue;
                dfs(to, v);
            }
        }

        int[] merge(int[] a, int[] b, int am) {
            List<Integer> res = new ArrayList<Integer>(am);
            int ptrA = 0, ptrB = 0;
            while (res.size() < am) {
                if (ptrA >= a.length && ptrB >= b.length) break;
                int ax = ptrA >= a.length ? Integer.MAX_VALUE : a[ptrA];
                int bx = ptrB >= b.length ? Integer.MAX_VALUE : b[ptrB];
                if (ax < bx) {
                    res.add(ax);
                    ++ptrA;
                } else {
                    res.add(bx);
                    ++ptrB;
                }
            }
            return ArrayUtils.toArray(res);
        }

        int[] get(int v, int p, int am) {
            int[] res = new int[0];
            for (int h = HEIGHT - 1; h >= 0; --h) {
                if (parent[h][v] == -1) continue;
                int vp = parent[h][v];
                if (order.isChild(p, vp) && p != vp) continue;
                res = merge(res, onPath[h][v], am);
                v = vp;
            }
            return res;
        }

    }

    static class InputReader {
        private BufferedReader reader;
        private StringTokenizer stt;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream));
        }

        public String nextLine() {
            try {
                return reader.readLine();
            } catch (IOException e) {
                return null;
            }
        }

        public String nextString() {
            while (stt == null || !stt.hasMoreTokens()) {
                stt = new StringTokenizer(nextLine());
            }
            return stt.nextToken();
        }

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

    }

    static class ArrayUtils {
        public static int[] toArray(Collection<Integer> collection) {
            int[] array = new int[collection.size()];
            int index = 0;
            for (int element : collection) {
                array[index++] = element;
            }
            return array;
        }

        public static void fill(int[][] f, int value) {
            for (int i = 0; i < f.length; ++i) {
                Arrays.fill(f[i], value);
            }
        }

    }

    static class Parent {
        public static int[] run(Graph tree, int root) {
            int[] parent = new int[tree.nVertex];
            int[] queue = new int[tree.nVertex];
            int front = 0, back = 0;
            queue[back++] = root;
            parent[root] = -1;
            while (front < back) {
                int v = queue[front++];
                for (int i = tree.first[v]; i != -1; i = tree.next[i]) {
                    if (parent[v] != tree.to[i]) {
                        queue[back++] = tree.to[i];
                        parent[tree.to[i]] = v;
                    }
                }
            }
            return parent;
        }

        public static int[][] getLevelParents(Graph tree, int root) {
            int maxLevel = 1;
            while ((1 << maxLevel) <= tree.nVertex) {
                ++maxLevel;
            }
            int[][] parent = new int[maxLevel][tree.nVertex];
            ArrayUtils.fill(parent, -1);
            parent[0] = Parent.run(tree, root);

            for (int level = 1; level < maxLevel; ++level) {
                for (int i = 0; i < tree.nVertex; ++i) {
                    if (parent[level - 1][i] != -1) {
                        int u = parent[level - 1][i];
                        if (parent[level - 1][u] != -1) {
                            int v = parent[level - 1][u];
                            parent[level][i] = v;
                        }
                    }
                }
            }
            return parent;
        }

    }

    static class DFSOrder {
        int[] start;
        int[] end;

        public DFSOrder(Graph tree, int root, int[] p) {
            start = new int[tree.nVertex];
            end = new int[tree.nVertex];
            buildDfsOrder(tree, root, p);
        }

        public boolean isChild(int candidate, int v) {
            return start[v] <= start[candidate] && end[v] >= end[candidate];
        }

        private void buildDfsOrder(Graph tree, int root, int[] p) {
            int[] stack = new int[2 * tree.nVertex];
            int top = 0;
            stack[top++] = (root + 1);
            int time = 0;
            while (top > 0) {
                --top;
                int v = stack[top];
                if (v < 0) {
                    v = (-v) - 1;
                    end[v] = time;
                    ++time;
                } else {
                    --v;
                    start[v] = time++;
                    stack[top++] = -(v + 1);
                    for (int i = tree.first[v]; i != -1; i = tree.next[i]) {
                        if (p[v] != tree.to[i]) {
                            stack[top++] = (tree.to[i] + 1);
                        }
                    }
                }
            }
        }

    }

    static class Graph {
        public int[] from;
        public int[] to;
        public int[] first;
        public int[] next;
        public int nVertex;
        public int nEdges;
        public int curEdge;

        public Graph() {
        }

        public void initGraph(int n, int m) {
            curEdge = 0;
            nVertex = n;
            nEdges = m;
            from = new int[m * 2];
            to = new int[m * 2];
            first = new int[n];
            next = new int[m * 2];
            Arrays.fill(first, -1);
        }

        public void addEdge(int a, int b) {
            next[curEdge] = first[a];
            first[a] = curEdge;
            to[curEdge] = b;
            from[curEdge] = a;
            ++curEdge;

            next[curEdge] = first[b];
            first[b] = curEdge;
            to[curEdge] = a;
            from[curEdge] = b;
            ++curEdge;
        }

    }
}

