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.util.*;
import java.io.*;

public class C326 {
	FastScanner in;
	PrintWriter out;

	int n, m, q;
	ArrayList<Integer>[] g;
	int max = 20;
	int[][] p;
	int[][][] mins;
	int[] depth;

	void dfs(int v, int par, int dep) {
		depth[v] = dep;
		for (int u : g[v]) {
			if (u != par) {
				p[0][u] = v;
				dfs(u, v, dep + 1);
			}
		}
	}

	int lca(int u, int v) {
		for (int i = max - 1; i >= 0; i--) {
			if (depth[p[i][u]] >= depth[v]) {
				u = p[i][u];
			}
			if (depth[p[i][v]] >= depth[u]) {
				v = p[i][v];
			}
		}
		if (u == v) {
			return u;
		}
		for (int i = max - 1; i >= 0; i--) {
			if (p[i][u] != p[i][v]) {
				u = p[i][u];
				v = p[i][v];
			}
		}
		return p[0][v];
	}

	int keepCnt = 10;
	int inf = (int) 1e9;

	int[] comb(int[] a, int[] b) {
		int[] c = new int[keepCnt];
		int pc = 0;
		int pa = 0, pb = 0;
		for (int i = 0; i < keepCnt; i++) {
			if (a[pa] < b[pb]) {
				c[pc++] = a[pa++];
			} else {
				c[pc++] = b[pb++];
			}
		}
		return c;
	}

	public void solve() throws IOException {
		n = in.nextInt();
		m = in.nextInt();
		q = in.nextInt();
		g = new ArrayList[n + 1];
		for (int i = 0; i <= n; i++) {
			g[i] = new ArrayList<>();
		}
		for (int i = 0; i < n - 1; i++) {
			int u = in.nextInt(), v = in.nextInt();
			g[u].add(v);
			g[v].add(u);
		}
		g[0].add(1);
		p = new int[max][n + 1];
		mins = new int[max][n + 1][keepCnt];
		depth = new int[n + 1];
		for (int i = 0; i <= n; i++) {
			Arrays.fill(mins[0][i], inf);
		}
		for (int i = 1; i <= m; i++) {
			int c = in.nextInt();
			for (int j = 0; j < keepCnt; j++) {
				if (i < mins[0][c][j]) {
					mins[0][c][j] = i;
					break;
				}
			}
		}
		dfs(0, -1, 0);
		for (int i = 1; i < max; i++) {
			for (int j = 0; j <= n; j++) {
				p[i][j] = p[i - 1][p[i - 1][j]];
				mins[i][j] = comb(mins[i - 1][j], mins[i - 1][p[i - 1][j]]);
			}
		}
		for (int i = 0; i < q; i++) {
			int v = in.nextInt(), u = in.nextInt(), a = in.nextInt();
			int w = lca(v, u);
			int[] res = mins[0][w];
			for (int j = max - 1; j >= 0; j--) {
				if (depth[p[j][v]] >= depth[w]) {
					res = comb(res, mins[j][v]);
			//		System.err.println(v + "->" + p[j][v]);
					v = p[j][v];
				}
				if (depth[p[j][u]] >= depth[w]) {
					res = comb(res, mins[j][u]);
			//		System.err.println(u + "->" + p[j][u]);
					u = p[j][u];
				}
			}
			int a2 = 0;
			while (a2 < res.length && res[a2] < inf) {
				a2++;
			}
			a = Math.min(a, a2);
			out.print(a + " ");
			for (int j = 0; j < a; j++) {
				out.print(res[j] + " ");
			}
			out.println();
		}
	}

	public void run() {
		try {
			in = new FastScanner();
			out = new PrintWriter(System.out);

			solve();

			out.close();
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	class FastScanner {
		BufferedReader br;
		StringTokenizer st;

		FastScanner() {
			br = new BufferedReader(new InputStreamReader(System.in));
		}

		String next() {
			while (st == null || !st.hasMoreTokens()) {
				try {
					st = new StringTokenizer(br.readLine());
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			return st.nextToken();
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		long nextLong() {
			return Long.parseLong(next());
		}

		double nextDouble() {
			return Double.parseDouble(next());
		}
	}

	public static void main(String[] arg) {
		new C326().run();
	}
}