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>

import java.io.*;
import java.math.*;
import java.util.*;

import static java.util.Arrays.fill;
import static java.lang.Math.*;
import static java.util.Arrays.sort;
import static java.util.Collections.sort;


public class E588 
{ 
	public static int mod = 1000000007;
	public static long INF = (1L << 60);
	static FastScanner2 in = new FastScanner2();
	static OutputWriter out = new OutputWriter(System.out);
	static ArrayList<Integer>[] adjacencylist=new ArrayList[100001];
	static int[] tin=new int[100001];
	static int[] tout=new int[100001];
	static int[][] up=new int[100001][20];
	static int[][] lives=new int[100001][10];
	static int[][][] mins=new int[100001][20][10];
	static int[] count=new int[100001];
	static int time=0;
	static int log=0;
	static int n,m;
	public static void dfs(int v,int parent)
	{
		tin[v]=++time;
		up[v][0]=parent;
		mins[v][0]=lives[v];
		for(int i=1;i<=log;i++)
		{
			up[v][i]=up[up[v][i-1]][i-1];
			mins[v][i]=merge(mins[up[v][i-1]][i-1], mins[v][i-1]);
		}
		for(int u : adjacencylist[v])
		{
			if(u!=parent)
			{
				dfs(u, v);
			}
		}
		tout[v]=++time;
	}
	public static boolean isancestor(int u,int v)
	{
		return tin[u]<=tin[v] && tout[u]>=tout[v];
	}
	public static int lca(int u,int v)
	{
		if(isancestor(u, v))
			return u;
		if(isancestor(v, u))
			return v;
		for(int i=log;i>=0;i--)
		{
			if(!isancestor(up[u][i], v))
				u=up[u][i];
		}
		return up[u][0];
	}
	public static int[] merge(int[] a,int[] b)
	{
		int[] c=new int[10];
		Arrays.fill(c, mod);
		int i=0,j=0;
		int count=0;
		while(count<10)
		{
			if(a[i]==mod && b[j]==mod)
				break;
			if(a[i]<b[j])
			{
				c[count++]=a[i++];
			}
			else
			{
				c[count++]=b[j++];
			}
		}
		return c;
	}
	public static int[] getpath(int u,int lca)
	{
		int[] ret=new int[10];
		Arrays.fill(ret, mod);
		if(u==lca)
			return ret;
		for(int i=log;i>=0;i--)
		{
			if(!isancestor(up[u][i], lca))
				{
				ret=merge(ret, mins[u][i]);
				u=up[u][i];
				}
		}
		ret=merge(ret, mins[u][0]);
		return ret;
	}
	public static void main(String[] args) 
	{

		for(int i=0;i<100001;i++)
		{
			Arrays.fill(lives[i], mod);
			Arrays.fill(up[i], 1);
			for(int j=0;j<10;j++)
			{
				Arrays.fill(mins[i][j], mod);
			}
		}
		n=in.nextInt();
		int power=1;
		while(power<=n)
		{
			log++;
			power=(power<<1);
		}
		for(int i=1;i<=n;i++)
		{
			adjacencylist[i]=new ArrayList<>();
		}
		m=in.nextInt();
		int queries=in.nextInt();
		for(int i=1;i<n;i++)
		{
			int u=in.nextInt();
			int v=in.nextInt();
			adjacencylist[u].add(v);
			adjacencylist[v].add(u);
		}
		for(int i=1;i<=m;i++)
		{
			int c=in.nextInt();
			if(count[c]<10)
			{
				lives[c][count[c]]=i;
				count[c]++;
			}
		}
		dfs(1, 1);
		while(queries-->0)
		{
			int u=in.nextInt();
			int v=in.nextInt();
			int a=in.nextInt();
			int lca=lca(u, v);
			int[] answer1=getpath(u, lca);
			int[] answer2=getpath(v, lca);
			int[] ans=merge(answer1, answer2);
			ans=merge(ans, lives[lca]);
			int count=0;
			for(int i=0;i<10;i++)
			{
				if(ans[i]==mod)
					break;
				count++;
			}
			out.print(min(count, a)+" ");
			for(int i=0;i<min(count, a);i++)
				out.print(ans[i]+" ");
			out.println();
		}
		out.close();

	}
	
	public static long pow(long x, long n) 
	{
		long res = 1;
		for (long p = x; n > 0; n >>= 1, p = (p * p)) 
		{
			if ((n & 1) != 0) 
			{
				res = (res * p);
			}
		}
		return res;
	}
	
	public static long pow(long x, long n, long mod) 
	{
		long res = 1;
		for (long p = x; n > 0; n >>= 1, p = (p * p) % mod) 
		{
			if ((n & 1) != 0) 
			{
				res = (res * p % mod);
			}
		}
		return res;
	}

	public static long gcd(long n1, long n2)
	{
		long r;
		while (n2 != 0) 
		{
			r = n1 % n2;
			n1 = n2;
			n2 = r;
		}
		return n1;
	}

	public static long lcm(long n1, long n2) 
	{
		long answer = (n1 * n2) / (gcd(n1, n2));
		return answer;
	}
	
	static class FastScanner2 
	{
		private byte[] buf = new byte[1024];
		private int curChar;
		private int snumChars;

		public int read() 
		{
			if (snumChars == -1)
				throw new InputMismatchException();
			if (curChar >= snumChars) 
			{
				curChar = 0;
				try 
				{
					snumChars = System.in.read(buf);
				} catch (IOException e) 
				{
					throw new InputMismatchException();
				}
				if (snumChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		public String nextLine() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do 
			{
				res.appendCodePoint(c);
				c = read();
			} 
			while (!isEndOfLine(c));
			return res.toString();
		}

		public String nextString() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do 
			{
				res.appendCodePoint(c);
				c = read();
			} 
			while (!isSpaceChar(c));
			return res.toString();
		}

		public long nextLong()
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			long res = 0;
			do 
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} 
			while (!isSpaceChar(c));
			return res * sgn;
		}

		public int nextInt() 
		{
			int c = read();
			while (isSpaceChar(c))
				c = read();
			int sgn = 1;
			if (c == '-') {
				sgn = -1;
				c = read();
			}
			int res = 0;
			do 
			{
				if (c < '0' || c > '9')
					throw new InputMismatchException();
				res *= 10;
				res += c - '0';
				c = read();
			} 
			while (!isSpaceChar(c));
			return res * sgn;
		}

		public int[] nextIntArray(int n)
		{
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) 
			{
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n)
		{
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) 
			{
				arr[i] = nextLong();
			}
			return arr;
		}

		private boolean isSpaceChar(int c)
		{
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		private boolean isEndOfLine(int c) 
		{
			return c == '\n' || c == '\r' || c == -1;
		}
	}

	static class InputReader 
	{
		public BufferedReader reader;
		public StringTokenizer tokenizer;

		public InputReader(InputStream inputstream) 
		{
			reader = new BufferedReader(new InputStreamReader(inputstream));
			tokenizer = null;
		}

		public String nextLine() 
		{
			String fullLine = null;
			while (tokenizer == null || !tokenizer.hasMoreTokens())
			{
				try 
				{
					fullLine = reader.readLine();
				} catch (IOException e)
				{
					throw new RuntimeException(e);
				}
				return fullLine;
			}
			return fullLine;
		}

		public String next()
		{
			while (tokenizer == null || !tokenizer.hasMoreTokens()) 
			{
				try 
				{
					tokenizer = new StringTokenizer(reader.readLine());
				} catch (IOException e) 
				{
					throw new RuntimeException(e);
				}
			}
			return tokenizer.nextToken();
		}

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

		public int[] nextIntArray(int n) 
		{
			int a[] = new int[n];
			for (int i = 0; i < n; i++) 
			{
				a[i] = nextInt();
			}
			return a;
		}

		public long[] nextLongArray(int n)
		{
			long a[] = new long[n];
			for (int i = 0; i < n; i++) 
			{
				a[i] = nextLong();
			}
			return a;
		}

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

	static class OutputWriter 
	{
		private final PrintWriter writer;

		public OutputWriter(OutputStream outputStream) 
		{
			writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
		}

		public OutputWriter(Writer writer)
		{
			this.writer = new PrintWriter(writer);
		}

		public void print(Object... objects)
		{
			for (int i = 0; i < objects.length; i++) 
			{
				if (i != 0)
					writer.print(' ');
				writer.print(objects[i]);
			}
		}

		public void println(Object... objects)
		{
			print(objects);
			writer.println();
		}

		public void close() 
		{
			writer.close();
		}

		public void flush() 
		{
			writer.flush();
		}
	}
private static boolean oj = System.getProperty("ONLINE_JUDGE") != null;
	
	private static void tr(Object... o) 
	{
		if (!oj)
			System.out.println(Arrays.deepToString(o));
	}
}