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.*;
import java.util.*;
import java.math.*;

public class C implements Runnable {
    private static BufferedReader in;
    private static PrintWriter out;
    private static StringTokenizer st;
    private static Random rnd;

    final int MAXLOG = 20;

    static class DynamicNode {
        DynamicNode l, r;
        int sum;
    }

    private void solve() throws IOException {
        int verticesCount = nextInt();
        int peopleCount = nextInt();
        int queriesCount = nextInt();
        List<Integer>[] edges = new ArrayList[verticesCount];
        List<Integer>[] whoLives = new ArrayList[verticesCount];
        for (int i = 0; i < verticesCount; i++) {
            edges[i] = new ArrayList<>();
            whoLives[i] = new ArrayList<>();
        }
        for (int i = 1; i < verticesCount; i++) {
            int u = nextInt() - 1, v = nextInt() - 1;
            edges[u].add(v);
            edges[v].add(u);
        }
        for (int i = 0; i < peopleCount; i++) {
            int city = nextInt() - 1;
            whoLives[city].add(i);
        }
        DynamicNode root = buildTree(0, peopleCount - 1);
        int[][] lca = new int[verticesCount][MAXLOG];
        int[] depths = new int[verticesCount];
        DynamicNode[] nodes = new DynamicNode[verticesCount];
        dfs(0, -1, 0, edges, whoLives, lca, root, depths, nodes, peopleCount);

        List<Integer> results = new ArrayList<>();

        for (int q = 0; q < queriesCount; q++) {
            int u = nextInt() - 1, v = nextInt() - 1, k = nextInt();
            int l = getLca(lca, depths, u, v);
            int p = lca[l][0];

            DynamicNode a = nodes[u], b = nodes[v];
            DynamicNode c = (p == -1 ? root : nodes[p]);

            results.clear();

            if (l != u && l != v)
                getResults3(0, peopleCount - 1, k, a, b, c, results);
            else if (l == u)
                getResults2(0, peopleCount - 1, k, b, c, results);
            else if (l == v)
                getResults2(0, peopleCount - 1, k, a, c, results);

            out.print(results.size());
            for (int j = 0; j < results.size(); j++) {
                out.print(' ');
                out.print(results.get(j) + 1);
            }
            out.println();
        }
    }

    private void getResults2(int l, int r, int k, DynamicNode a, DynamicNode c, List<Integer> results) {
        if (k <= 0)
            return;
        int currentSum = a.sum - c.sum;
        if (currentSum <= 0)
            return;
        if (k <= results.size())
            return;
        if (l == r) {
            results.add(l);
        } else {
            int m = (l + r) / 2;
            getResults2(l, m, k, a.l, c.l, results);
            getResults2(m + 1, r, k, a.r, c.r, results);
        }
    }

    private void getResults3(int l, int r, int k, DynamicNode a, DynamicNode b, DynamicNode c, List<Integer> results) {
        if (k <= 0)
            return;
        if (k <= results.size())
            return;
        int currentSum = a.sum + b.sum - 2 * c.sum;
        if (currentSum <= 0)
            return;
        if (l == r) {
            results.add(l);
        } else {
            int m = (l + r) / 2;
            getResults3(l, m, k, a.l, b.l, c.l, results);
            getResults3(m + 1, r, k, a.r, b.r, c.r, results);
        }
    }

    private int getLca(int[][] lca, int[] depths, int u, int v) {
        if (depths[u] < depths[v]) {
            int t = u;
            u = v;
            v = t;
        }
        for (int it = MAXLOG - 1; it >= 0; it--) {
            int p = lca[u][it];
            if (p != -1 && depths[p] >= depths[v])
                u = p;
        }
        if (u == v)
            return u;
        if (depths[u] != depths[v])
            throw new AssertionError();
        for (int it = MAXLOG - 1; it >= 0; it--) {
            if (lca[u][it] != lca[v][it]) {
                u = lca[u][it];
                v = lca[v][it];
            }
        }
        u = lca[u][0];
        v = lca[v][0];
        if (u != v || u == -1)
            throw new AssertionError();
        return u;
    }

    private void dfs(int u, int p, int h, List<Integer>[] edges, List<Integer>[] whoLives, int[][] lca,
            DynamicNode root, int[] depths, DynamicNode[] nodes, int peopleCount) {
        depths[u] = h;
        Arrays.fill(lca[u], -1);

        lca[u][0] = p;
        for (int i = 1; i < MAXLOG; i++) {
            int j = lca[u][i - 1];
            if (j != -1)
                lca[u][i] = lca[j][i - 1];
        }

        for (int id : whoLives[u]) {
            root = addId(root, 0, peopleCount - 1, id);
        }
        nodes[u] = root;

        for (int v : edges[u]) {
            if (v != p) {
                dfs(v, u, h + 1, edges, whoLives, lca, root, depths, nodes, peopleCount);
            }
        }
    }

    private DynamicNode addId(DynamicNode root, int l, int r, int id) {
        if (l == r) {
            DynamicNode newNode = new DynamicNode();
            newNode.sum = root.sum + 1;
            return newNode;
        } else {
            int m = (l + r) / 2;
            DynamicNode newNode = new DynamicNode();
            newNode.l = root.l;
            newNode.r = root.r;
            if (id <= m)
                newNode.l = addId(root.l, l, m, id);
            else
                newNode.r = addId(root.r, m + 1, r, id);
            newNode.sum = newNode.l.sum + newNode.r.sum;
            return newNode;
        }
    }

    private DynamicNode buildTree(int l, int r) {
        if (l == r) {
            return new DynamicNode();
        } else {
            int m = (l + r) / 2;
            DynamicNode node = new DynamicNode();
            node.l = buildTree(l, m);
            node.r = buildTree(m + 1, r);
            return node;
        }
    }

    public static void main(String[] args) {
        new C().run();
    }

    public void run() {
        try {
            final String className = this.getClass().getName().toLowerCase();

            try {
                in = new BufferedReader(new FileReader(className + ".in"));
                out = new PrintWriter(new FileWriter(className + ".out"));
                // in = new BufferedReader(new FileReader("input.txt"));
                // out = new PrintWriter(new FileWriter("output.txt"));
            } catch (FileNotFoundException e) {
                in = new BufferedReader(new InputStreamReader(System.in));
                out = new PrintWriter(System.out);
            }

            rnd = new Random();

            solve();

            out.close();
        } catch (IOException e) {
            e.printStackTrace();
            System.exit(42);
        }
    }

    private String nextToken() throws IOException {
        while (st == null || !st.hasMoreTokens()) {
            String line = in.readLine();

            if (line == null)
                return null;

            st = new StringTokenizer(line);
        }

        return st.nextToken();
    }

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

    private long nextLong() throws IOException {
        return Long.parseLong(nextToken());
    }

    private double nextDouble() throws IOException {
        return Double.parseDouble(nextToken());
    }
}