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 *c*<sub class="lower-index">*i*</sub>. Note that there may be more than one person in a city, also there may be no people living in the city.

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 *p*<sub class="lower-index">1</sub>, *p*<sub class="lower-index">2</sub>, ..., *p*<sub class="lower-index">*x*</sub> in increasing order. 

If *k* = *min*(*x*, *a*), then Duff should tell Malek numbers *k*, *p*<sub class="lower-index">1</sub>, *p*<sub class="lower-index">2</sub>, ..., *p*<sub class="lower-index">*k*</sub> 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.
The first line of input contains three integers, *n*, *m* and *q* (1 ≤ *n*, *m*, *q* ≤ 10<sup class="upper-index">5</sup>).

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 *c*<sub class="lower-index">1</sub>, *c*<sub class="lower-index">2</sub>, ..., *c*<sub class="lower-index">*m*</sub> separated by spaces (1 ≤ *c*<sub class="lower-index">*i*</sub> ≤ *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).
from sys import stdin,stdout 
import math,sys
sys.setrecursionlimit(2*(10**5))
n,m,q=stdin.readline().strip().split(' ');n,m,q=int(n),int(m),int(q)
base2depth=int(math.log(n,2))
adj   =[[] for i in range(n)]
cities=[[] for i in range(n)]
height=[-1 for i in range(n)]

p     =[[-1 for j in range(base2depth)] for i in range(n+1)]
topten=[[[] for j in range(base2depth)] for i in range(n+1)]


for i in range(n-1):
	v,u=stdin.readline().strip().split(' ');v,u=int(v),int(u)
	adj[v-1].append(u-1);adj[u-1].append(v-1)

cit=list(map(int,stdin.readline().strip().split(' ')))
for i in range(len(cit)):
	cities[cit[i]-1].append(i+1);
	cities[cit[i]-1]=sorted(cities[cit[i]-1])[:10]




def dfs(currentnode,parentnode,h):
	global adj,p,height,topten
	height[currentnode]=h
	if parentnode!=-1:
		topten[currentnode][0]=cities[parentnode]
	p[currentnode][0]=parentnode

	for i in adj[currentnode]:
		if i!=parentnode:
			dfs(i,currentnode,h+1)

dfs(0,-1,0)

for j in range(1,base2depth):
	for i in range(n):
		if p[i][j-1]!=-1:
			p[i][j]=p[p[i][j-1]][j-1];
			topten[i][j]=sorted(topten[i][j-1]+topten[p[i][j-1]][j-1])[:10]

# for i in range(len(p)):
# 	print(p[i],' p[{0}]'.format(i))

# print('')

# for i in range(len(topten)):
# 	print(topten[i],' topten[{0}]'.format(i))


def mainstuff(v,u,a):
	v,u=v-1,u-1
	
	if height[v]<height[u]:
		v,u=u,v
	# V is always higher
	diff = height[v]-height[u]

	if diff==0:
		if u!=v:
			ansarr=cities[v]+cities[u]
			for i in range(base2depth-1,-1,-1):
				if p[u][i] != p[v][i]:
					ansarr=sorted(ansarr+topten[v][i]+topten[u][i])[:a]
					u=p[u][i]
					v=p[v][i]
			ansarr=sorted(ansarr+cities[p[u][0]])[:a]
		else:
			ansarr=cities[u][:a]
	else:
		ansarr=cities[v][:a]
		#print(ansarr)
		for i in range(0,base2depth):
			if (diff>>i)&1:
				#print(v,ansarr,"ohh")
				ansarr=sorted(ansarr+topten[v][i])[:a]
				v=p[v][i]
		#print(ansarr)
		if u!=v:
			ansarr=sorted(ansarr+cities[u])[:a]
			for i in range(base2depth-1,-1,-1):
				if p[u][i] != p[v][i]:
					ansarr=sorted(ansarr+topten[v][i]+topten[u][i])[:a]
					u=p[u][i]
					v=p[v][i]
			ansarr=sorted(ansarr+cities[p[u][0]])[:a]
	stdout.write(str(len(ansarr))+' ');
	for i in range(len(ansarr)):
		stdout.write(str(ansarr[i])+' ')
	stdout.write('\n')


for _ in range(q):
	v,u,a=map(int,stdin.readline().strip().split(' '))
	mainstuff(v,u,a)



