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.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.PrintWriter;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;

@SuppressWarnings("unchecked")
public class A587 {
	
	int n, m, q;
	int[] a, loc, sizes, p, chain, first, rfirst, rev, startChain, chainSize, depth, input[], topNode, bottomNode;
	ArrayList<Integer>[] vs;
	RMQ rmq;
	
	int dfs(int node, int par, int dep) {
		int size = 1; depth[node] = dep; p[node] = par;
		for(int i : vs[node]) if(i != par) size += dfs(i, node, dep + 1);
		return sizes[node] = size;
	}
	
	int curChain, idx;
	void hldfs(int node, int par, int chainId) {
		chain[node] = chainId; rfirst[idx] = node; first[node] = idx++; ++chainSize[chainId];
		if(startChain[chainId] == -1) startChain[chainId] = node;
		int maxChild = -1, maxSize = -1;
		for(int i : vs[node]) if(i != par) {
			if(maxSize < sizes[i]) {
				maxSize = sizes[i];
				maxChild = i;
			}
		}
		if(maxChild == -1) return;
		hldfs(maxChild, node, chainId);
		for(int i : vs[node]) if(i != par && i != maxChild) {
			hldfs(i, node, ++curChain);
		}
	}
	
	int lca(int u, int v) {
		int uChain = chain[u], vChain = chain[v];
		if(uChain == vChain) return depth[u] < depth[v] ? u : v;
		if(depth[startChain[uChain]] > depth[startChain[vChain]]) return lca(p[startChain[uChain]], v);
		else return lca(u, p[startChain[vChain]]);
	}
	
	String query(int u, int v, int lca, int cap) {
		ArrayDeque<Range> ranges = new ArrayDeque<>();
		while(chain[u] != chain[lca]) {
			Range r = new Range(first[startChain[chain[u]]], first[u]);
			ranges.add(r);
			u = p[startChain[chain[u]]];
		}
		while(chain[v] != chain[lca]) {
			Range r = new Range(first[startChain[chain[v]]], first[v]);
			ranges.add(r);
			v = p[startChain[chain[v]]];
		}
//		ranges.add(new Range(first[lca], Math.max(first[u], first[v])));
		ranges.add(new Range(first[topNode[rev[lca]]], Math.max(first[bottomNode[rev[u]]], first[bottomNode[rev[v]]])));
		ArrayList<Integer> list = new ArrayList<>();
		while(list.size() < cap) {
			Pair bestCur = new Pair(-1, Integer.MAX_VALUE);
			Range bestRange = null;
			for(Range r : ranges) {
				Pair cur = rmq.query(r.l, r.r);
				if(cur.val < bestCur.val) {
					bestCur = cur;
					bestRange = r;
				}
			}
			if(bestRange == null) break;
			ArrayDeque<Range> tmp = new ArrayDeque<>();
			for(Range r : ranges) if(r != bestRange) tmp.add(r);
			list.add(bestCur.val);
			Range left = new Range(bestRange.l, bestCur.ind - 1);
			Range right = new Range(bestCur.ind + 1, bestRange.r);
			if(left.l <= left.r) tmp.add(left);
			if(right.l <= right.r) tmp.add(right);
			ranges = tmp;
		}
		String ans = "" + list.size();
		for(int i = 0; i < list.size(); ++i) ans += " " + list.get(i);
		return ans;
	}
	
	void buildGraph() {
		int[] nodes = new int[n];
		for(int i = 0; i < m; ++i) nodes[loc[i]]++;
		for(int i = 0; i < n; ++i) nodes[i] = Math.max(1, nodes[i]);
		topNode = new int[n]; Arrays.fill(topNode, -1);
		bottomNode = new int[n]; Arrays.fill(bottomNode, -1);
		int ind = 0;
		for(int i = 0; i < n; ++i) {
			topNode[i] = ind;
			ind += nodes[i];
			bottomNode[i] = ind - 1;
			for(int j = topNode[i]; j <= bottomNode[i] - 1; ++j) {
				vs[j].add(j + 1);
			}
		}
		ArrayList<Integer>[] initGraph = new ArrayList[n];
		for(int i = 0; i < n; ++i) initGraph[i] = new ArrayList<>();
		for(int i = 0; i < n - 1; ++i) {
			int u = input[0][i], v = input[1][i];
			initGraph[u].add(v); initGraph[v].add(u);
		}
		ArrayDeque<Integer> q = new ArrayDeque<>();
		q.add(0); q.add(-1);
		while(!q.isEmpty()) {
			int node = q.poll();
			int par = q.poll();
			for(int i : initGraph[node]) if(i != par) {
				vs[bottomNode[node]].add(topNode[i]);
				q.add(i); q.add(node);
			}
		}
		Arrays.fill(a, Integer.MAX_VALUE);
		ArrayDeque<Integer>[] qs = new ArrayDeque[n];
		for(int i = 0; i < n; ++i) qs[i] = new ArrayDeque<Integer>();
		for(int i = 0; i < m; ++i) qs[loc[i]].add(i + 1);
		for(int i = 0; i < n; ++i) {
			for(int j = topNode[i]; !qs[i].isEmpty() && j <= bottomNode[i]; ++j) {
				a[j] = qs[i].poll();
			}
			for(int j = topNode[i]; j <= bottomNode[i]; ++j) {
				rev[j] = i;
			}
		}
	}
	
	public void solve(JS in, PrintWriter out) {
		n = in.nextInt();
		m = in.nextInt();
		q = in.nextInt();
		loc = new int[m];
		a = new int[n + m];
		sizes = new int[n + m];
		p = new int[n + m];
		depth = new int[n + m];
		vs = new ArrayList[n + m];
		chain = new int[n + m];
		startChain = new int[n + m]; Arrays.fill(startChain, -1);
		chainSize = new int[n + m];
		first = new int[n + m];
		rfirst = new int[n + m];
		rev = new int[n + m];
		input = new int[2][n - 1];
		curChain = idx = 0;
		for(int i = 0; i < n + m; ++i) vs[i] = new ArrayList<>();
		for(int i = 0; i < n - 1; ++i) {
			int u = in.nextInt() - 1, v = in.nextInt() - 1;
			input[0][i] = u; input[1][i] = v;
		}
		for(int i = 0; i < m; ++i) loc[i] = in.nextInt() - 1;
		buildGraph();
		dfs(0, -1, 0);
		hldfs(0, -1, 0);
		int[] b = a.clone();
		for(int i = 0; i < idx; ++i) b[first[i]] = a[i];
		rmq = new RMQ(b);
		while(q-->0) {
			int u = in.nextInt() - 1, v = in.nextInt() - 1;
			int cap = in.nextInt();
			int lca = lca(bottomNode[u], bottomNode[v]);
			out.println(query(bottomNode[u], bottomNode[v], lca, cap));
		}
	}
	
	public static void main(String[] args) {
		System.err.println("go!");
		JS in = new JS();
		PrintWriter out = new PrintWriter(System.out);
		new A587().solve(in, out);
		out.close();
	}
	
	class Range {
		int l, r;
		Range(int ll, int rr) {
			l = ll; r = rr;
		}
		public String toString() {
			return String.format("(%d, %d)", l, r);
		}
	}
	
	class Pair {
		int val, ind;
		Pair(int i, int v) {
			ind = i; val = v;
		}
	}
	
	Pair min(Pair a, Pair b) {
		return a.val < b.val ? a : b;
	}
	
	class RMQ {
		int[] vs;
		Pair[][] lift;

		public RMQ(int[] vs) {
			this.vs = vs;
			int n = vs.length;
			int maxlog = Integer.numberOfTrailingZeros(Integer.highestOneBit(n)) + 2;
			lift = new Pair[maxlog][n];
			for (int i = 0; i < n; i++)
				lift[0][i] = new Pair(i, vs[i]);
			int lastRange = 1;
			for (int lg = 1; lg < maxlog; lg++) {
				for (int i = 0; i < n; i++) {
					lift[lg][i] = min(lift[lg - 1][i], lift[lg - 1][Math.min(i + lastRange, n - 1)]);
				}
				lastRange *= 2;
			}
		}

		public Pair query(int low, int hi) {
			if(low > hi) throw new RuntimeException("WTF");
			int range = hi - low + 1;
			int exp = Integer.highestOneBit(range);
			int lg = Integer.numberOfTrailingZeros(exp);
			return min(lift[lg][low], lift[lg][hi - exp + 1]);
		}
	}
	
	static class JS {
		public int BS = 1<<16;
		public char NC = (char)0;
		byte[] buf = new byte[BS];
		int bId = 0, size = 0;
		char c = NC;
		double num = 1;
		BufferedInputStream in;

		public JS() {
			in = new BufferedInputStream(System.in, BS);
		}

		public JS(String s) throws FileNotFoundException {
			in = new BufferedInputStream(new FileInputStream(new File(s)), BS);
		}

		public char nextChar(){
			while(bId==size) {
				try {
					size = in.read(buf);
				}catch(Exception e) {
					return NC;
				}
				if(size==-1)return NC;
				bId=0;
			}
			return (char)buf[bId++];
		}

		public int nextInt() {
			return (int)nextLong();
		}

		public long nextLong() {
			num=1;
			boolean neg = false;
			if(c==NC)c=nextChar();
			for(;(c<'0' || c>'9'); c = nextChar()) {
				if(c=='-')neg=true;
			}
			long res = 0;
			for(; c>='0' && c <='9'; c=nextChar()) {
				res = (res<<3)+(res<<1)+c-'0';
				num*=10;
			}
			return neg?-res:res;
		}

		public double nextDouble() {
			double cur = nextLong();
			return c!='.' ? cur:cur+(cur < 0 ? -1*nextLong()/num : nextLong()/num);
		}

		public String next() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c>32) {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public String nextLine() {
			StringBuilder res = new StringBuilder();
			while(c<=32)c=nextChar();
			while(c!='\n') {
				res.append(c);
				c=nextChar();
			}
			return res.toString();
		}

		public boolean hasNext() {
			if(c>32)return true;
			while(true) {
				c=nextChar();
				if(c==NC)return false;
				else if(c>32)return true;
			}
		}
	}
}