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.OutputStream;
import java.io.PrintWriter;
import java.io.BufferedWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.util.TreeSet;
import java.util.ArrayList;
import java.util.List;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.Comparator;
import java.io.InputStream;

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

    static class EDuffInTheArmy {
        EDuffInTheArmy.SparseTableLca st;
        int[] h;
        int log;
        List[][] stpl;
        int[][] stp;

        public void solve(int testNumber, InputReader in, OutputWriter out) {

            int n = in.nextInt();
            int m = in.nextInt();

            int q = in.nextInt();

            List[] g = new List[n];

            in.readUndirectedGraph(g, n, n - 1, 1);

            int[] c = in.nextIntArray(m);

            List[] nl = new List[n];
            for (int i = 0; i < n; i++) {
                nl[i] = new ArrayList();
            }
            for (int i = 0; i < m; i++) {
                nl[c[i] - 1].add(i);
            }

            for (int i = 0; i < n; i++) {
                nl[i].sort(Comparator.naturalOrder());
            }

            st = new EDuffInTheArmy.SparseTableLca(g, nl);

            h = st.h;

            log = st.log;

            stpl = st.stpl;

            stp = st.stp;

            while (q-- > 0) {
                int u = in.nextInt() - 1;
                int v = in.nextInt() - 1;

                int a = in.nextInt();

                int lca = st.lca(u, v);

                List<Integer> l1 = solve(u, lca, a);
                List<Integer> l2 = solve(v, lca, a);

                TreeSet<Integer> ans = mergeSet(l1, l2, a);

                out.print(ans.size() + " ");
                for (int val : ans) {
                    out.print(val + 1 + " ");
                }

                out.println();
            }
        }

        List<Integer> solve(int u, int lca, int a) {
            int d = h[u] - h[lca] + 1;

            int nod = u;

            List<Integer> cl = new ArrayList<>();
            for (int i = log; i >= 0; i--) {
                if ((1 << i) <= d) {
                    d -= (1 << i);
                    cl = merge(cl, stpl[nod][i], a);
                    nod = stp[nod][i];
                }
            }

            return cl;
        }

        List<Integer> merge(List<Integer> l1, List<Integer> l2, int a) {
            List<Integer> l = new ArrayList<>();

            int x = 0, y = 0;

            while (x < l1.size() && y < l2.size() && l.size() < a) {
                if (l1.get(x) <= l2.get(y)) {
                    l.add(l1.get(x));
                    x++;
                } else {
                    l.add(l2.get(y));
                    y++;
                }
            }

            while (x < l1.size() && l.size() < a) {
                l.add(l1.get(x));
                x++;
            }

            while (y < l2.size() && l.size() < a) {
                l.add(l2.get(y));
                y++;
            }

            return l;
        }

        TreeSet<Integer> mergeSet(List<Integer> l1, List<Integer> l2, int a) {
            TreeSet<Integer> l = new TreeSet<>();

            int x = 0, y = 0;

            while (x < l1.size() && y < l2.size() && l.size() < a) {
                if (l1.get(x) <= l2.get(y)) {
                    l.add(l1.get(x));
                    x++;
                } else {
                    l.add(l2.get(y));
                    y++;
                }
            }

            while (x < l1.size() && l.size() < a) {
                l.add(l1.get(x));
                x++;
            }

            while (y < l2.size() && l.size() < a) {
                l.add(l2.get(y));
                y++;
            }

            return l;
        }

        static class SparseTableLca {
            List[] g;
            int[] p;
            int[] pw;
            int[] h;
            int n;
            int log = 0;
            int[][] stp;
            int[][] stpw;
            List[][] stpl;

            public SparseTableLca(List[] g, List[] nl) {
                this.g = g;
                this.n = g.length;
                this.p = new int[n];
                this.pw = new int[n];
                this.h = new int[n];
                int cn = n;
                while (cn > 0) {
                    cn /= 2;
                    log++;
                }
                this.stp = new int[n][log + 1];
                this.stpw = new int[n][log + 1];
                this.stpl = new List[n][log + 1];
                dfs(0, 0, 0);
                for (int i = 0; i < n; i++) {
                    stp[i][0] = p[i];
                    stpw[i][0] = pw[i];
                    stpl[i][0] = new ArrayList();
                    stpl[i][0].addAll(nl[i]);
                }
                init();
            }

            void dfs(int u, int cp, int ch) {
                p[u] = cp;
                pw[u] = 1;
                h[u] = ch;

                for (int i = 0; i < g[u].size(); i++) {
                    int v = (int) g[u].get(i);

                    if (v != cp) {
                        dfs(v, u, ch + 1);
                    }
                }
            }

            public SparseTableLca(int[] p, int[] pw, int[] h) {
                this.p = p;
                this.pw = pw;
                this.h = h;
                this.n = p.length;

                int cn = n;
                while (cn > 0) {
                    cn /= 2;
                    log++;
                }

                this.stp = new int[n][log + 1];
                this.stpw = new int[n][log + 1];

                for (int i = 0; i < n; i++) {
                    stp[i][0] = p[i];
                    stpw[i][0] = pw[i];
                }
            }

            void init() {
                for (int i = 1; i <= log; i++) {
                    for (int j = 0; j < n; j++) {
                        stp[j][i] = stp[stp[j][i - 1]][i - 1];
                        stpw[j][i] = Math.max(stpw[j][i - 1], stpw[stp[j][i - 1]][i - 1]);

                        List<Integer> l1 = stpl[j][i - 1];
                        List<Integer> l2 = stpl[stp[j][i - 1]][i - 1];

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

                        int x = 0, y = 0;

                        while (x < l1.size() && y < l2.size() && l.size() < 10) {
                            if (l1.get(x) <= l2.get(y)) {
                                l.add(l1.get(x));
                                x++;
                            } else {
                                l.add(l2.get(y));
                                y++;
                            }
                        }

                        while (x < l1.size() && l.size() < 10) {
                            l.add(l1.get(x));
                            x++;
                        }

                        while (y < l2.size() && l.size() < 10) {
                            l.add(l2.get(y));
                            y++;
                        }

                        stpl[j][i] = l;
                    }
                }
            }

            int lca(int u, int v) {
                if (h[u] < h[v]) {
                    int t = u;
                    u = v;
                    v = t;
                }

                int h1 = h[u];
                int h2 = h[v];

                if (h1 > h2) {
                    int d = h1 - h2;
                    int cu = u;
                    for (int i = log; i >= 0; i--) {
                        if (d >= 1 << i) {
                            cu = stp[cu][i];
                            d -= (1 << i);
                        }
                    }
                    u = cu;
                }

                if (u == v) {
                    return u;
                }

                for (int i = log; i >= 0; i--) {
                    if (stp[u][i] != stp[v][i]) {
                        u = stp[u][i];
                        v = stp[v][i];
                    }
                }

                return p[u];
            }

        }

    }

    static class OutputWriter {
        private final PrintWriter writer;

        public OutputWriter(OutputStream outputStream) {
            writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
        }

        public OutputWriter(Writer writer) {
            this.writer = new PrintWriter(writer);
        }

        public void print(Object... objects) {
            for (int i = 0; i < objects.length; i++) {
                if (i != 0) {
                    writer.print(' ');
                }
                writer.print(objects[i]);
            }
        }

        public void println() {
            writer.println();
        }

        public void close() {
            writer.close();
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.SpaceCharFilter filter;

        public InputReader(InputStream stream) {
            this.stream = stream;
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public int read() {
            if (numChars == -1) {
                throw new InputMismatchException();
            }
            if (curChar >= numChars) {
                curChar = 0;
                try {
                    numChars = stream.read(buf);
                } catch (IOException e) {
                    throw new InputMismatchException();
                }
                if (numChars <= 0) {
                    return -1;
                }
            }
            return buf[curChar++];
        }

        public int nextInt() {
            int c = read();
            while (isSpaceChar(c)) {
                c = read();
            }
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            int res = 0;
            do {
                if (c < '0' || c > '9') {
                    throw new InputMismatchException();
                }
                res *= 10;
                res += c - '0';
                c = read();
            } while (!isSpaceChar(c));
            return res * sgn;
        }

        public boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public int[] nextIntArray(int n) {
            int[] array = new int[n];
            for (int i = 0; i < n; ++i) array[i] = nextInt();
            return array;
        }

        public void readUndirectedGraph(List[] g, int numOfVertices, int numOfEdges, int offset) {
            for (int i = 0; i < numOfVertices; i++) {
                g[i] = new ArrayList();
            }

            for (int i = 0; i < numOfEdges; i++) {
                int u = nextInt() - offset;
                int v = nextInt() - offset;

                if (u == v)
                    continue;

                g[u].add(v);
                g[v].add(u);
            }
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}