```go
package main

import (
	"fmt"
	"math"
	"sort"
	"strings"
)

const LOG = 18

var adj [][]int
var people [][]int
var depth []int
var up [][]int
var sz []int
var heavy []int
var chainIdx []int
var posInChain []int
var chainHeads []int
var chainLists [][]int
var segTrees [][][]int

func dfsSize(node, par, dep int) {
	depth[node] = dep
	up[node][0] = par
	sz[node] = 1
	maxChild := -1
	heavy[node] = -1
	for _, child := range adj[node] {
		if child != par {
			dfsSize(child, node, dep+1)
			sz[node] += sz[child]
			if sz[child] > maxChild {
				maxChild = sz[child]
				heavy[node] = child
			}
		}
	}
}

func dfsHLD(node, par, chn int) {
	chainIdx[node] = chn
	posInChain[node] = len(chainLists[chn])
	chainLists[chn] = append(chainLists[chn], node)
	if heavy[node] != -1 {
		dfsHLD(heavy[node], node, chn)
	}
	for _, child := range adj[node] {
		if child != par && child != heavy[node] {
			newchn := len(chainLists)
			chainLists = append(chainLists, []int{})
			chainHeads = append(chainHeads, child)
			dfsHLD(child, node, newchn)
		}
	}
}

func build(chn, node, start, end int) {
	if start == end {
		nd := chainLists[chn][start]
		segTrees[chn][node] = make([]int, len(people[nd]))
		copy(segTrees[chn][node], people[nd])
		return
	}
	mid := (start + end) / 2
	build(chn, 2*node, start, mid)
	build(chn, 2*node+1, mid+1, end)
	left := segTrees[chn][2*node]
	right := segTrees[chn][2*node+1]
	merged := make([]int, len(left)+len(right))
	i, j, k := 0, 0, 0
	for i < len(left) && j < len(right) {
		if left[i] < right[j] {
			merged[k] = left[i]
			i++
		} else {
			merged[k] = right[j]
			j++
		}
		k++
	}
	copy(merged[k:], left[i:])
	k += len(left) - i
	copy(merged[k:], right[j:])
	segTrees[chn][node] = merged
}

func querySeg(chn, node, start, end, l, r int) [][]int {
	if r < start || end < l {
		return [][]int{}
	}
	if l <= start && end <= r {
		return [][]int{segTrees[chn][node]}
	}
	mid := (start + end) / 2
	lef := querySeg(chn, 2*node, start, mid, l, r)
	rig := querySeg(chn, 2*node+1, mid+1, end, l, r)
	return append(lef, rig...)
}

func getLCA(a, b int) int {
	if depth[a] > depth[b] {
		a, b = b, a
	}
	diff := depth[b] - depth[a]
	for j := 0; j < LOG; j++ {
		if (diff & (1 << j)) != 0 {
			b = up[b][j]
		}
	}
	if a == b {
		return a
	}
	for j := LOG - 1; j >= 0; j-- {
		if up[a][j] != up[b][j] {
			a = up[a][j]
			b = up[b][j]
		}
	}
	return up[a][0]
}

func climb(from, to int, include bool) [][]int {
	var vecs [][]int
	cur := from
	for chainIdx[cur] != chainIdx[to] {
		ch := chainIdx[cur]
		hpos := posInChain[chainHeads[ch]]
		cpos := posInChain[cur]
		q := querySeg(ch, 1, 0, len(chainLists[ch])-1, hpos, cpos)
		vecs = append(vecs, q...)
		cur = up[chainHeads[ch]][0]
	}
	ch := chainIdx[cur]
	tpos := posInChain[to]
	cpos := posInChain[cur]
	startpos := tpos
	if !include {
		startpos = tpos + 1
	}
	if startpos <= cpos {
		q := querySeg(ch, 1, 0, len(chainLists[ch])-1, startpos, cpos)
		vecs = append(vecs, q...)
	}
	return vecs
}

func getPathVectors(v, u int) [][]int {
	lca := getLCA(v, u)
	var vecs [][]int
	if v == lca {
		vecs = climb(u, lca, true)
	} else if u == lca {
		vecs = climb(v, lca, true)
	} else {
		vvec := climb(v, lca, true)
		uvec := climb(u, lca, false)
		vecs = append(vvec, uvec...)
	}
	return vecs
}

func main() {
	var n, m, q int
	fmt.Scan(&n, &m, &q)
	adj = make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		var a, b int
		fmt.Scan(&a, &b)
		adj[a] = append(adj[a], b)
		adj[b] = append(adj[b], a)
	}
	people = make([][]int, n+1)
	for i := 1; i <= m; i++ {
		var ci int
		fmt.Scan(&ci)
		people[ci] = append(people[ci], i)
	}
	for i := 1; i <= n; i++ {
		sort.Ints(people[i])
	}
	depth = make([]int, n+1)
	sz = make([]int, n+1)
	heavy = make([]int, n+1)
	for i := range heavy {
		heavy[i] = -1
	}
	up = make([][]int, n+1)
	for i := range up {
		up[i] = make([]int, LOG)
	}
	dfsSize(1, 0, 0)
	for j := 1; j < LOG; j++ {
		for i := 1; i <= n; i++ {
			if up[i][j-1] != 0 {
				up[i][j] = up[up[i][j-1]][j-1]
			}
		}
	}
	chainIdx = make([]int, n+1)
	posInChain = make([]int, n+1)
	chainLists = make([][]int, 1)
	chainLists[0] = []int{}
	chainHeads = make([]int, 1)
	chainHeads[0] = 1
	dfsHLD(1, 0, 0)
	segTrees = make([][][]int, len(chainLists))
	for chn := 0; chn < len(chainLists); chn++ {
		csz := len(chainLists[chn])
		if csz == 0 {
			continue
		}
		segTrees[chn] = make([][]int, 4*csz)
		build(chn, 1, 0, csz-1)
	}
	var out strings.Builder
	for qi := 0; qi < q; qi++ {
		var v, u, a int
		fmt.Scan(&v, &u, &a)
		vecs := getPathVectors(v, u)
		currPos := make([]int, len(vecs))
		result := []int{}
		for len(result) < a {
			minVal := math.MaxInt32
			minLi := -1
			for li := 0; li < len(vecs); li++ {
				if currPos[li] < len(vecs[li]) && vecs[li][currPos[li]] < minVal {
					minVal = vecs[li][currPos[li]]
					minLi = li
				}
			}
			if minLi == -1 {
				break
			}
			result = append(result, minVal)
			currPos[minLi]++
		}
		out.WriteString(fmt.Sprintf("%d", len(result)))
		for _, p := range result {
			out.WriteString(fmt.Sprintf(" %d", p))
		}
		out.WriteString("\n")
	}
	fmt.Print(out.String())
}
```