package main

import (
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < fs.n && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

type Item struct {
	cnt uint8
	a   [10]int32
}

func merge(x, y Item) Item {
	var z Item
	i, j := 0, 0
	cx, cy := int(x.cnt), int(y.cnt)
	for z.cnt < 10 && (i < cx || j < cy) {
		if j >= cy || (i < cx && x.a[i] < y.a[j]) {
			z.a[z.cnt] = x.a[i]
			i++
		} else {
			z.a[z.cnt] = y.a[j]
			j++
		}
		z.cnt++
	}
	return z
}

func lca(u, v int, up [][]int, depth []int) int {
	if depth[u] < depth[v] {
		u, v = v, u
	}
	diff := depth[u] - depth[v]
	k := 0
	for diff > 0 {
		if diff&1 == 1 {
			u = up[k][u]
		}
		diff >>= 1
		k++
	}
	if u == v {
		return u
	}
	for k = len(up) - 1; k >= 0; k-- {
		if up[k][u] != up[k][v] {
			u = up[k][u]
			v = up[k][v]
		}
	}
	return up[0][u]
}

func collect(v, dist int, up [][]int, best [][]Item) Item {
	var res Item
	k := 0
	for dist > 0 {
		if dist&1 == 1 {
			res = merge(res, best[k][v])
			v = up[k][v]
		}
		dist >>= 1
		k++
	}
	return res
}

func appendInt(dst []byte, x int) []byte {
	return strconv.AppendInt(dst, int64(x), 10)
}

func main() {
	fs := NewFastScanner()

	n := fs.NextInt()
	m := fs.NextInt()
	q := fs.NextInt()

	head := make([]int, n+1)
	for i := 1; i <= n; i++ {
		head[i] = -1
	}
	to := make([]int, 2*(n-1))
	nxt := make([]int, 2*(n-1))
	ei := 0

	for i := 0; i < n-1; i++ {
		v := fs.NextInt()
		u := fs.NextInt()

		to[ei] = u
		nxt[ei] = head[v]
		head[v] = ei
		ei++

		to[ei] = v
		nxt[ei] = head[u]
		head[u] = ei
		ei++
	}

	log := 0
	for (1 << log) <= n {
		log++
	}

	up := make([][]int, log)
	best := make([][]Item, log)
	up[0] = make([]int, n+1)
	best[0] = make([]Item, n+1)

	for id := 1; id <= m; id++ {
		c := fs.NextInt()
		if best[0][c].cnt < 10 {
			best[0][c].a[best[0][c].cnt] = int32(id)
			best[0][c].cnt++
		}
	}

	depth := make([]int, n+1)
	stack := make([]int, 1, n)
	stack[0] = 1

	for len(stack) > 0 {
		v := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		for e := head[v]; e != -1; e = nxt[e] {
			u := to[e]
			if u != up[0][v] {
				up[0][u] = v
				depth[u] = depth[v] + 1
				stack = append(stack, u)
			}
		}
	}

	for k := 1; k < log; k++ {
		up[k] = make([]int, n+1)
		best[k] = make([]Item, n+1)
		pu := up[k-1]
		pb := best[k-1]
		cu := up[k]
		cb := best[k]
		for v := 1; v <= n; v++ {
			mid := pu[v]
			if mid != 0 {
				cu[v] = pu[mid]
				cb[v] = merge(pb[v], pb[mid])
			} else {
				cb[v] = pb[v]
			}
		}
	}

	out := make([]byte, 0, q*48)

	for i := 0; i < q; i++ {
		v := fs.NextInt()
		u := fs.NextInt()
		a := fs.NextInt()

		w := lca(v, u, up, depth)
		res := merge(collect(v, depth[v]-depth[w], up, best), collect(u, depth[u]-depth[w], up, best))
		res = merge(res, best[0][w])

		k := int(res.cnt)
		if k > a {
			k = a
		}

		out = appendInt(out, k)
		for j := 0; j < k; j++ {
			out = append(out, ' ')
			out = appendInt(out, int(res.a[j]))
		}
		out = append(out, '\n')
	}

	os.Stdout.Write(out)
}