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

class Segtree:
    def __init__(self, data, f):
        self.f = f
        self.data = [0]*len(data)
        self.data += data
        for i in reversed(range(1, len(data))):
            self.data[i] = f(self.data[2 * i], self.data[2 * i + 1])
    def __call__(self, l, r):
        l += len(self.data) >> 1
        r += len(self.data) >> 1
        val = self.data[l]
        l += 1
        while l < r:
            if l & 1:
                val = self.f(val, self.data[l])
                l += 1
            if r & 1:
                r -= 1
                val = self.f(val, self.data[r])
            l >>= 1
            r >>= 1
        return val

class Hld:
    def __init__(self, graph, data, f = min):
        root = 0
        n = len(graph) + 1
        self.data = data
        self.f = f
        
        bfs = [root]
        self.depth = [-1]*n
        self.depth[root] = 0
        self.P = [-1]*n
        for node in bfs:
            for nei in graph[node]:
                if self.depth[nei] == -1:
                    bfs.append(nei)
                    self.P[nei] = node
                    self.depth[nei] = 1 + self.depth[node]

        fam_size = [1]*n
        preffered_child = list(range(n))
        for node in reversed(bfs):
            p = self.P[node]
            if fam_size[preffered_child[p]] <= fam_size[node]:
                preffered_child[p] = node
            fam_size[p] += fam_size[node]
        fam_size[root] //= 2

        self.hld_P = list(range(n))
        self.prefix_values = [0]*n
        values = [[] for _ in range(n)]
        for node in bfs:
            self.hld_P[preffered_child[node]] = self.hld_P[node]
            values[self.hld_P[node]].append(data[node])
            self.prefix_values[node] = data[node] if node == self.hld_P[node] else f(self.prefix_values[self.P[node]], data[node])
        self.seg_values = [self.builder(value) for value in values]

    def builder(self, data):
        self.f = f
        ans = [0]*len(data)
        ans += data
        for i in reversed(range(1, len(data))):
            ans[i] = self.f(ans[2 * i], ans[2 * i + 1])
        return ans

    def query(self, data, l, r):
        l += len(data) >> 1
        r += len(data) >> 1
        val = data[l]
        l += 1
        while l < r:
            if l & 1:
                val = self.f(val, data[l])
                l += 1
            if r & 1:
                r -= 1
                val = self.f(val, data[r])
            l >>= 1
            r >>= 1
        return val


    def __call__(self, u,v):
        if u == v:
            return self.data[u]
        if self.depth[u] < self.depth[v]:
            u,v = v,u
        val = self.data[u]
        u = self.P[u]

        uhld = self.hld_P[u]
        vhld = self.hld_P[v]
        while uhld != vhld:
            if self.depth[uhld] >= self.depth[vhld]:
                val = self.f(self.prefix_values[u], val)
                u = self.P[uhld]
                uhld = self.hld_P[u]
            else:
                val = self.f(self.prefix_values[v], val)
                v = self.P[vhld]
                vhld = self.hld_P[v]
        if self.depth[u] < self.depth[v]:
            u,v = v,u
        return self.f(
                self.query(self.seg_values[uhld],
                    self.depth[v] - self.depth[uhld], 
                    self.depth[u] - self.depth[uhld] + 1)
                , val)


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()
hld = Hld(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(hld(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)