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.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;

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

    static class TaskE {
        int n;
        int m;
        int q;
        int u;
        int v;
        int a;
        int len;
        List<Integer>[] T;
        List<Integer>[] L;
        int[] depth;
        int[][] parent;
        int[][][] up;
        int[][] dpLca;
        int[] tin;
        int[] tout;
        boolean[] visit;
        PrintWriter out;
        int time = 0;

        public void solve(int testNumber, QuickScanner in, PrintWriter out) {
            this.out = out;
            readInput(in);

            for (int i = 0; i < q; i++) {
                u = in.nextInt() - 1;
                v = in.nextInt() - 1;
                a = in.nextInt();
                int lc = __lca(u, v);
                int[] ans;
                if (lc == u) ans = getSet(v, u);
                else if (lc == v) ans = getSet(u, v);
                else ans = merge(getSet(u, lc), getSet(v, lc));
                if (ans == null) out.println(0);
                else {
                    int sz = Math.min(a, ans.length);
                    out.print(sz);
                    for (int j = 0; j < sz; j++) {
                        out.print(" " + ans[j]);
                    }
                    out.println();
                }
            }
        }

        int[] getSet(int u, int p) {
            if (u == p) return up[u][0];
            int du = depth[u];
            int dp = depth[p];
            int lg = len - 1;
            while ((1 << lg) > du - dp) lg--;
            int[] ret = up[u][lg];
            if (parent[u][lg] != p) {
                ret = merge(ret, getSet(parent[u][lg], p));
            } else ret = merge(ret, up[p][0]);
            return ret;
        }

        void init() {
            dfs(0, 0, 0);

            for (int i = 0; i < n; i++) {
                up[i][0] = new int[L[i].size()];
                for (int j = 0; j < L[i].size(); j++) {
                    up[i][0][j] = L[i].get(j);
                }
            }

            for (int lg = 1; lg < len; ++lg) {
                for (int u = 0; u < n; u++) {
                    if (parent[u][lg - 1] != -1) {
                        parent[u][lg] = parent[parent[u][lg - 1]][lg - 1];
                    }
                }
            }

            for (int lg = 1; lg < len; ++lg) {
                for (int u = 0; u < n; u++) {
                    if (parent[u][lg - 1] != -1) {
                        up[u][lg] = merge(up[u][lg - 1], up[parent[u][lg - 1]][lg - 1]);
                    }
                }
            }
        }

        boolean isParent(int parent, int child) {
            return tin[parent] <= tin[child] && tout[child] <= tout[parent];
        }

        int __lca(int a, int b) {
            if (isParent(a, b)) return a;
            if (isParent(b, a)) return b;
            for (int i = len - 1; i >= 0; i--) {
                if (!isParent(dpLca[i][a], b))
                    a = dpLca[i][a];
            }
            return dpLca[0][a];
        }

        void dfs(int u, int d, int p) {
            tin[u] = time++;
            depth[u] = d;
            dpLca[0][u] = p;
            visit[u] = true;
            for (int i = 1; i < len; i++) {
                dpLca[i][u] = dpLca[i - 1][dpLca[i - 1][u]];
            }
            for (Integer v : T[u]) {
                if (!visit[v]) {
                    dfs(v, d + 1, u);
                    parent[v][0] = u;
                }
            }
            tout[u] = time++;
        }

        int[] merge(int[] a, int[] b) {
            if (a == null) return b;
            if (b == null) return a;
            int[] ret = new int[a.length + b.length];
            int pa = 0, pb = 0, cnt = 0, pos = 0;
            while (cnt < 10 && pa < a.length && pb < b.length) {
                if (a[pa] < b[pb]) {
                    if (pos == 0 || ret[pos - 1] < a[pa]) {
                        ret[pos++] = a[pa];
                        cnt++;
                    }
                    pa++;
                } else {
                    if (pos == 0 || ret[pos - 1] < b[pb]) {
                        ret[pos++] = b[pb];
                        cnt++;
                    }
                    pb++;
                }
            }
            while (cnt < 10 && pa < a.length) {
                if (pos == 0 || ret[pos - 1] < a[pa]) {
                    ret[pos++] = a[pa];
                    cnt++;
                }
                pa++;
            }
            while (cnt < 10 && pb < b.length) {
                if (pos == 0 || ret[pos - 1] < b[pb]) {
                    ret[pos++] = b[pb];
                    cnt++;
                }
                pb++;
            }
            int[] rr = new int[Math.min(cnt, 10)];
            Arrays.fill(rr, -1);
            System.arraycopy(ret, 0, rr, 0, Math.min(cnt, 10));
            return rr;
        }

        public void readInput(QuickScanner in) {
            n = in.nextInt();
            m = in.nextInt();
            q = in.nextInt();
            T = new List[n];
            L = new List[n];
            depth = new int[n];
            visit = new boolean[n];
            while ((1 << len) <= n) len++;
            up = new int[n][len][];
            parent = new int[n][len];
            dpLca = new int[len][n];
            tin = new int[n];
            tout = new int[n];
            for (int i = 0; i < n; i++) {
                T[i] = new ArrayList<>();
                L[i] = new ArrayList<>();
                Arrays.fill(parent[i], -1);
            }
            for (int i = 1; i < n; i++) {
                u = in.nextInt() - 1;
                v = in.nextInt() - 1;
                T[u].add(v);
                T[v].add(u);
            }
            for (int i = 0; i < m; i++) {
                L[in.nextInt() - 1].add(i + 1);
            }
            init();
        }

    }

    static class QuickScanner {
        BufferedReader br;
        StringTokenizer st;
        InputStream is;

        public QuickScanner(InputStream stream) {
            is = stream;
            br = new BufferedReader(new InputStreamReader(stream), 32768);
        }

        String nextToken() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(nextToken());
        }

    }
}