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>
//package codeforces.cfr326div2;

import java.io.*;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

/**
 * Created by raggzy on 31-Oct-15.
 */
public class F {

    static final int MAX_LOG = 18;
    static final int MAX_SIZE = 10;

    static int n;
    static int m;
    static int q;
    static City[] cities;


    static class City {
        int height;
        KMins[] mins = new KMins[MAX_LOG];
        int[] parents = new int[MAX_LOG];
        List<Integer> neighbors = new LinkedList<>();
        List<Integer> people = new LinkedList<>();
    }

    static class KMins {
        int[] arr = new int[MAX_SIZE];
        int[] tmp = new int[MAX_SIZE];

        {
            clear();
        }

        private static void merge(int[] arr1, int[] arr2, int[] dest) {
            int arr1C = 0;
            int arr2C = 0;
            for (int i = 0; i < MAX_SIZE; i++) {
                int tmpO = arr1C < arr1.length ? arr1[arr1C] : Integer.MAX_VALUE;
                int otherO = arr2C < arr2.length ? arr2[arr2C] : Integer.MAX_VALUE;
                if (tmpO == otherO) {
                    dest[i] = tmpO;
                    arr1C++;
                    arr2C++;
                } else if (tmpO < otherO) {
                    dest[i] = tmpO;
                    arr1C++;
                } else {
                    dest[i] = otherO;
                    arr2C++;
                }
                if (dest[i] == Integer.MAX_VALUE) break;
            }
        }

        KMins mergeWith(int[] other) {
            System.arraycopy(arr, 0, tmp, 0, MAX_SIZE);
            merge(other, tmp, arr);
            return this;
        }

        KMins initFrom(KMins one, KMins two) {
            merge(one.arr, two.arr, arr);
            return this;
        }

        KMins mergeWith(List<Integer> list) {
            int i = 0;
            for (int v : list) {
                arr[i++] = v;
                if (i >= MAX_SIZE) break;
            }
            return this;
        }

        KMins mergeWith(KMins other) {
            return mergeWith(other.arr);
        }

        void sout(int a, StringBuilder sb) {
            int count = 0;
            for (int i = 0; i < MAX_SIZE; i++) {
                if (arr[i] < Integer.MAX_VALUE) {
                    count++;
                    sb.append(" ").append(arr[i]);
                }
                if (count >= a) {
                    break;
                }
            }
            sb.insert(0, count);
        }

        void clear() {
            Arrays.fill(arr, Integer.MAX_VALUE);
        }

    }

    private static void calcStuff(int curr, int prev, int h, int[] parents) {
        City city = cities[curr];
        city.height = h;
        city.parents[0] = curr;
        city.mins[0] = new KMins().mergeWith(city.people);
        parents[h] = curr;
        for (int i = 1; i < MAX_LOG; i++) {
            int jump = 1 << (i - 1);
            int parentIdx = Math.max(0, h - jump);
            city.parents[i] = parents[parentIdx];
            City midParent = cities[city.parents[i - 1]];
            city.mins[i] = new KMins().initFrom(city.mins[i - 1], midParent.mins[i - 1]);
        }
        for (int neigh : city.neighbors) {
            if (neigh != prev) {
                calcStuff(neigh, curr, h + 1, parents);
            }
        }
    }

    private static int lcaHeight(City one, City two) {
        for (int jmp = MAX_LOG - 1; jmp >= 0; jmp--) {
            if (one.parents[jmp] != two.parents[jmp]) {
                one = cities[cities[one.parents[jmp]].parents[1]];
                two = cities[cities[two.parents[jmp]].parents[1]];
            }
        }
        return one.height;
    }

    private static City parent(City city, int parentHeight) {
        for (int jmp = MAX_LOG - 1; jmp >= 0; jmp--) {
            City parent = cities[city.parents[jmp]];
            if (parent.height >= parentHeight) {
                city = parent;
            }
        }
        return city;
    }

    private static void mergeKmins(City city, int parentHeight, KMins dest) {
        for (int jmp = MAX_LOG - 1; jmp >= 0; jmp--) {
            City parent = cities[city.parents[jmp]];
            if (parent.height >= parentHeight) {
                dest.mergeWith(city.mins[jmp]);
                city = parent;
            }
        }
    }

    private static void query(City one, City two, KMins result) {
        if (one.height < two.height) {
            City tmp = one;
            one = two;
            two = tmp;
        }
        // eq height
        mergeKmins(one, two.height, result);
        one = parent(one, two.height);
        int lcaHeight = lcaHeight(one, two);
        mergeKmins(one, lcaHeight, result);
        mergeKmins(two, lcaHeight, result);
    }

    private static int nextInt(StreamTokenizer in) throws IOException {
        in.nextToken();
        return (int) in.nval;
    }

    public static void main(String[] args) throws IOException {
        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
        PrintStream out = new PrintStream(System.out);
//        StreamTokenizer in = new StreamTokenizer(new BufferedReader(new FileReader("C:/Temp/test.in")));
//        PrintStream out = new PrintStream(new FileOutputStream("C:/Temp/test.out"));
        n = nextInt(in);
        m = nextInt(in);
        q = nextInt(in);

        cities = new City[1 + n];

        for (int i = 1; i <= n; i++) {
            cities[i] = new City();
        }

        for (int i = 0; i < n - 1; i++) {
            int v1 = nextInt(in);
            int v2 = nextInt(in);
            cities[v1].neighbors.add(v2);
            cities[v2].neighbors.add(v1);
        }

        for (int i = 0; i < m; i++) {
            int c = nextInt(in);
            cities[c].people.add(1 + i);
        }
        int[] tmp = new int[n];
        calcStuff(1, 0, 0, tmp);

        KMins tmpKmins = new KMins();
        StringBuilder tmpBuilder = new StringBuilder(100);
        for (int i = 0; i < q; i++) {
            int u = nextInt(in);
            int v = nextInt(in);
            int a = nextInt(in);
            tmpKmins.clear();
            tmpBuilder.setLength(0);
            query(cities[u], cities[v], tmpKmins);
            tmpKmins.sout(a, tmpBuilder);
            out.println(tmpBuilder.toString());
        }
        System.out.println();
    }
}
