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.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class E {
	public static void main(String[] args) throws IOException {
		try (FastScanner s = new FastScanner()) {
			final int n = s.nextInt();
			final int m = s.nextInt();
			final int q = s.nextInt();
			graph = new ArrayList<>(n);
			for (int i = 0; i < n; ++i) {
				graph.add(new ArrayList<Integer>());
			}
			for (int i = 0; i < n - 1; ++i) {
				final int a = s.nextInt() - 1;
				final int b = s.nextInt() - 1;
				graph.get(a).add(b);
				graph.get(b).add(a);
			}
			c = new int[n][MAX_PATH_LENGTH];
			for (int i = 0; i < n; ++i) {
				Arrays.fill(c[i], Integer.MAX_VALUE);
			}
			int[] count = new int[n];
			for (int i = 0; i < m; ++i) {
				int city = s.nextInt() - 1;
				count[city]++;
				if (count[city] <= MAX_PATH_LENGTH) {
					c[city][count[city] - 1] = (i + 1);
				}
			}
			tin = new int[n];
			tout = new int[n];
			l = 1;
			while ((1 << l) <= n) {
				l++;
			}
			up = new int[n][l + 1];
			paths = new int[n][l + 1][MAX_PATH_LENGTH];
			for (int i = 0; i < n; ++i) {
				for (int j = 0; j <= l; ++j) {
					Arrays.fill(paths[i][j], Integer.MAX_VALUE);
				}
			}
			dfs(0, 0);
			for (int i = 0; i < q; ++i) {
				final int u = s.nextInt() - 1;
				final int v = s.nextInt() - 1;
				final int a = s.nextInt();
				final int[] path = lca(u, v);
				int k = 0;
				for (int j = 0; j < a; ++j) {
					if (path[j] == Integer.MAX_VALUE) {
						break;
					}
					k++;
				}
				System.out.print(k + " ");
				for (int j = 0; j < k; ++j) {
					System.out.print(path[j] + " ");
				}
				System.out.println();
			}
		}
	}
	
	private static final int MAX_PATH_LENGTH = 10;
	private static int[] tin;
	private static int[] tout;
	private static int[][] up;
	private static int timer;
	private static int l;
	private static List<List<Integer>> graph;
	private static int[][] c;
	private static int[][][] paths;

	private static void dfs(int v, int p) {
		tin[v] = ++timer;
		up[v][0] = p;
		merge(paths[v][0], c[v], c[p]);
		for (int i = 1; i <= l; ++i) {
			up[v][i] = up[up[v][i - 1]][i - 1];
			merge(paths[v][i], paths[v][i - 1], paths[up[v][i - 1]][i - 1]);
		}
		for (int i : graph.get(v)) {
			if (i != p) {
				dfs(i, v);
			}
		}
		tout[v] = ++timer;
	}
	
	private static boolean upper(int a, int b) {
		return tin[a] <= tin[b] && tout[a] >= tout[b];
	}
	
	private static int[] lca_merge(int a, int b) {
		int[][] path = new int[2][MAX_PATH_LENGTH];
		Arrays.fill(path[0], Integer.MAX_VALUE);
		Arrays.fill(path[1], Integer.MAX_VALUE);
		int p = 0;
		for (int i = l; i >= 0; --i) {
			if (!upper(up[a][i], b)) {
				merge(path[p ^ 1], path[p], paths[a][i]);
				a = up[a][i];
				p ^= 1;
			}
		}
		merge(path[p ^ 1], path[p], paths[a][0]);
		return path[p ^ 1];
	}

	private static int[] lca(int a, int b) {
		if (a == b) {
			return c[a];
		}
		if (upper(a, b)) {
			return lca_merge(b, a);
		}
		if (upper(b, a)) {
			return lca_merge(a, b);
		}
		int[] path = new int[MAX_PATH_LENGTH];
		merge(path, lca_merge(b, a), lca_merge(a, b));
		return path;
	}
	
	private static void merge(int[] to, int[] from1, int[] from2) {
		int i = 0;
		int j = 0;
		int l = 0;
		while (l < MAX_PATH_LENGTH) {
			if (from1[i] < from2[j]) {
				to[l++] = from1[i++];
			} else if (from1[i] > from2[j]){
				to[l++] = from2[j++];
			} else {
				to[l++] = from1[i++];
				j++;
			}
		}
	}
	
	private static class FastScanner implements AutoCloseable {
		private final BufferedReader reader;
		private String[] buffer;
		private int next;

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

		int nextInt() throws IOException {
			if (buffer == null || (next == buffer.length)) {
				buffer = reader.readLine().split(" ");
				next = 0;
			}
			return Integer.parseInt(buffer[next++]);
		}
		
		public void close() throws IOException {
			reader.close();
		}
	}
}