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.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.io.StreamTokenizer;
import java.util.Arrays;

public class C {

    static void solve() throws IOException {
        int n = nextInt();
        int p = nextInt();
        int q = nextInt();
        Tree tree = new Tree( n );
        for ( int i = 0; i < p; i ++ ) {
            int v = nextInt() - 1;
            tree.v[v].ten[0].add( i );
        }
        tree.init();
        for ( int i = 0; i < q; i ++ ) {
            int u = nextInt() - 1;
            int w = nextInt() - 1;
            int l = nextInt();
            tree.getTen( u, w ).print( l );
        }
    }

    private static class TenPeople {
        public static final TenPeople EMPTY = new TenPeople();

        int[] p;

        TenPeople() {
            p = new int[11];
            Arrays.fill( p, Integer.MAX_VALUE );
        }
        TenPeople( int[] P ) {
            p = P;
        }

        void add( int x ) {
            p[10] = x;
            Arrays.sort( p );
        }

        TenPeople merge( TenPeople tp ) {
            int[] r = new int[11];
            for ( int i = 0, j = 0, k = 0; k < 11 && ( i < 11 || j < 11 ); ) {
                if ( i >= 11 ) {
                    r[k ++] = tp.p[j ++];
                } else if ( j >= 11 ) {
                    r[k ++] = p[i ++];
                } else if ( p[i] < tp.p[j] ) {
                    r[k ++] = p[i ++];
                } else {
                    r[k ++] = tp.p[j ++];
                    if ( p[i] == tp.p[j - 1] ) i ++;
                }
            }
            return new TenPeople( r );
        }

        public void print( int cnt ) {
            int l = 0;
            for ( ; l < p.length && p[l] < Integer.MAX_VALUE; l ++ );
            l = Math.min( l, cnt );
            out.print( l );
            for ( int i = 0; i < l; i ++ ) {
                out.print( " " + ( p[i] + 1 ) );
            }
            out.println();
        }
    }

    private static class Vertex {
        int id;
        Vertex[] e;
        int depth;
        Vertex[] up;
        TenPeople[] ten;

        public Vertex( int Id, int d ) {
            id = Id;
            e = new Vertex[d];
        }

        public int up( int d ) {
            Vertex cur = this;
            for ( int i = 1, m = 1; d > 0; i ++, m <<= 1 ) {
                if ( ( d & m ) != 0 ) {
                    cur = cur.up[i];
                    d -= m;
                }
            }
            return cur.id;
        }

        public TenPeople ten( int d ) {
            Vertex cur = this;
            TenPeople tp = ten[0];
            for ( int i = 1, m = 1; d > 0; i ++, m <<= 1 ) {
                if ( ( d & m ) != 0 ) {
                    tp = tp.merge( cur.ten[i] );
                    cur = cur.up[i];
                    d -= m;
                }
            }
            return tp;
        }
    }

    private static class Tree {
        Vertex[] v;

        Tree( int n ) throws IOException {
            v = new Vertex[n];
            int[] a = new int[n - 1];
            int[] b = new int[n - 1];
            int[] d = new int[n];
            for ( int i = 0; i < n - 1; i ++ ) {
                a[i] = nextInt() - 1;
                b[i] = nextInt() - 1;
                d[a[i]] ++;
                d[b[i]] ++;
            }
            for ( int i = 0; i < n; i ++ ) {
                v[i] = new Vertex( i, d[i] );
            }
            for ( int i = 0; i < n - 1; i ++ ) {
                v[a[i]].e[-- d[a[i]]] = v[b[i]];
                v[b[i]].e[-- d[b[i]]] = v[a[i]];
            }
            int log = 2;
            for ( int n2 = 1; n2 <= v.length; n2 *= 2 ) {
                log ++;
            }
            for ( Vertex u : v ) {
                u.up = new Vertex[log + 1];
                u.ten = new TenPeople[log + 1];
                u.ten[0] = new TenPeople();
            }
        }

        public void init() {
            dfs( 0, -1, 0 );
            for ( int i = 2; i < v[0].up.length; i ++ ) {
                for ( Vertex u : v ) {
                    u.up[i] = u.up[i - 1].up[i - 1];
                    u.ten[i] = u.ten[i - 1].merge( u.up[i - 1].ten[i - 1] );
                }
            }
        }

        private void dfs( int u, int p, int d ) {
            v[u].up[1] = p >= 0 ? v[p] : v[u];
            v[u].ten[1] = v[u].ten[0].merge( p >= 0 ? v[p].ten[0] : TenPeople.EMPTY );
            v[u].depth = d;
            for ( Vertex w : v[u].e ) {
                if ( w.id != p ) dfs( w.id, u, d + 1 );
            }
        }

        public TenPeople getTen( int u, int w ) {
            int minD = Math.min( v[u].depth, v[w].depth );
            int l = 0;
            int r = minD;
            while ( l < r ) {
                int m = ( l + r ) / 2;
                if ( v[u].up( m + v[u].depth - minD ) == v[w].up( m + v[w].depth - minD ) ) {
                    r = m;
                } else {
                    l = m + 1;
                }
            }
            return v[u].ten( l + v[u].depth - minD ).merge( v[w].ten( l + v[w].depth - minD ) );
        }
    }

    static StreamTokenizer in;
    static PrintWriter out;

    static int nextInt() throws IOException {
        in.nextToken();
        return ( int ) in.nval;
    }

    public static void main( String[] args ) throws IOException {
        in = new StreamTokenizer( new InputStreamReader( System.in ) );
        out = new PrintWriter( System.out );
        solve();
        out.close();
    }
}