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 PYTHON):

Solution:
import sys
range = xrange
input = raw_input

## LCA
class RangeQuery:
    def __init__(self, data, func=min):
        self.func = func
        self._data = _data = [list(data)]
        i, n = 1, len(_data[0])
        while 2 * i <= n:
            prev = _data[-1]
            _data.append([func(prev[j], prev[j + i]) for j in range(n - 2 * i + 1)])
            i <<= 1

    def __call__(self, begin, end):
        depth = (end - begin).bit_length() - 1
        return self.func(self._data[depth][begin], self._data[depth][end - (1 << depth)])


class LCA:
    def __init__(self, root, graph):
        self.time = [-1] * len(graph)
        self.path = []
        dfs = [root]
        while dfs:
            node = dfs.pop()
            self.path.append(node)
            if self.time[node] == -1:
                self.time[node] = len(self.path) - 1
                for nei in graph[node]:
                    if self.time[nei] == -1:
                        dfs.append(node)
                        dfs.append(nei)
        self.rmq = RangeQuery(self.time[node] for node in self.path)

    def __call__(self, a, b):
        a = self.time[a]
        b = self.time[b]
        if a > b:
            a, b = b, a
        return self.path[self.rmq(a, b + 1)]
## END LCA

class Binary_lifting:
    def __init__(self, graph, data, f = min):
        root = 0
        self.lca = LCA(root, graph)
        self.f = f
        self.data = data

        self.P = [[] for _ in range(n)]
        self.values = [[] for _ in range(n)]
        self.depth = [-1]*n
        self.depth[root] = 0
        bfs = [root]
        for node in bfs:
            for nei in graph[node]:
                if self.depth[nei] == -1:
                    self.depth[nei] = 1 + self.depth[node]
                    bfs.append(nei)
                    value = data[nei]
                    self.values[nei].append(value)
                    p = node
                    self.P[nei].append(p)
                    for i in range(self.depth[nei].bit_length() - 1):
                        value = f(value, self.values[p][i])
                        self.values[nei].append(value)
                        p = self.P[p][i]
                        self.P[nei].append(p)

    def __call__(self, u, v):
        w = self.lca(u,v)
        value = self.data[w]
        for node in u,v:
            d = self.depth[node] - self.depth[w]
            while d:
                i = (d ^ d - 1).bit_length() - 1
                d -= 1 << i
                value = self.f(value, self.values[node][i])
                node = self.P[node][i]
        return value


inp = [int(x) for x in sys.stdin.read().split()]; ii = 0

n = inp[ii]; ii += 1
m = inp[ii]; ii += 1
q = inp[ii]; ii += 1

coupl = [[] for _ in range(n)]
for _ in range(n - 1):
    u = inp[ii] - 1; ii += 1
    v = inp[ii] - 1; ii += 1

    coupl[u].append(v)
    coupl[v].append(u)

def f(A, B):
    ans = []
    A = list(A)
    B = list(B)
    goal = min(10, len(A) + len(B))
    while len(ans) < goal:
        if A and (not B or A[-1] < B[-1]):
            ans.append(A.pop())
        else:
            ans.append(B.pop())
    ans.reverse()
    return ans

C = inp[ii:ii + m]; ii += m
data = [[] for _ in range(n)]
for i in range(m):
    if len(data[C[i] - 1]) < 10:
        data[C[i] - 1].append(i + 1)
for d in data:
    d.reverse()
BL = Binary_lifting(coupl, data, f)

out = []
for _ in range(q):
    v = inp[ii] - 1; ii += 1
    u = inp[ii] - 1; ii += 1
    a = inp[ii]; ii += 1

    ans = list(BL(v, u))
    ans.append(min(len(ans), a))
    out.append(' '.join(str(x) for x in ans[-1:~a-1:-1]))
print '\n'.join(out)