For problem statement at 1000-1999/1900-1999/1950-1959/1957/problemF2.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1950-1959/1957/verifierF2.go ends with case 11 failed
input:
6
3 5 1 1 4 1
1 2
1 3
2 4
4 5
2 6
2
4 5 1 3 1
4 5 4 3 1

expected:
0
1 1
got:
1 3
1 1
exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"fmt"
	"os"
)

type Node struct {
	L, R uint32
	val  uint64
}

var (
	tree    []Node
	nodeCnt uint32
	R_arr   [100005]uint64
	up      [100005][18]int
	depth   [100005]int
	root    [100005]uint32
	adj     [][]int
	a       []int
	ans     []int
)

func init() {
	seed := uint64(88172645463325252)
	for i := 1; i <= 100000; i++ {
		seed ^= seed << 13
		seed ^= seed >> 7
		seed ^= seed << 17
		R_arr[i] = seed
	}
}

func insert(prev uint32, L, R, c int) uint32 {
	nodeCnt++
	curr := nodeCnt
	tree[curr] = tree[prev]
	tree[curr].val += R_arr[c]
	if L == R {
		return curr
	}
	mid := (L + R) / 2
	if c <= mid {
		tree[curr].L = insert(tree[prev].L, L, mid, c)
	} else {
		tree[curr].R = insert(tree[prev].R, mid+1, R, c)
	}
	return curr
}

func dfs(u, p, d int) {
	up[u][0] = p
	depth[u] = d
	root[u] = insert(root[p], 1, 100000, a[u])
	for i := 1; i < 18; i++ {
		up[u][i] = up[up[u][i-1]][i-1]
	}
	for _, v := range adj[u] {
		if v != p {
			dfs(v, u, d+1)
		}
	}
}

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

func dfs_seg(n1, n2, n3, n4, m1, m2, m3, m4 uint32, L, R, k int) {
	if len(ans) == k {
		return
	}
	val1 := tree[n1].val + tree[n2].val - tree[n3].val - tree[n4].val
	val2 := tree[m1].val + tree[m2].val - tree[m3].val - tree[m4].val
	if val1 == val2 {
		return
	}
	if L == R {
		ans = append(ans, L)
		return
	}
	mid := (L + R) / 2
	dfs_seg(tree[n1].L, tree[n2].L, tree[n3].L, tree[n4].L, tree[m1].L, tree[m2].L, tree[m3].L, tree[m4].L, L, mid, k)
	if len(ans) < k {
		dfs_seg(tree[n1].R, tree[n2].R, tree[n3].R, tree[n4].R, tree[m1].R, tree[m2].R, tree[m3].R, tree[m4].R, mid+1, R, k)
	}
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024*10)

	scanInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}
	res := 0
	for _, b := range scanner.Bytes() {
		res = res*10 + int(b-'0')
	}
	n := res

	a = make([]int, n+1)
	for i := 1; i <= n; i++ {
		a[i] = scanInt()
	}

	adj = make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		u := scanInt()
		v := scanInt()
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	tree = make([]Node, n*40+100000)
	nodeCnt = 0

	dfs(1, 0, 1)

	q := scanInt()
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	for i := 0; i < q; i++ {
		u1 := scanInt()
		v1 := scanInt()
		u2 := scanInt()
		v2 := scanInt()
		k := scanInt()

		lca1 := lca(u1, v1)
		plca1 := up[lca1][0]
		lca2 := lca(u2, v2)
		plca2 := up[lca2][0]

		ans = ans[:0]
		dfs_seg(root[u1], root[v1], root[lca1], root[plca1], root[u2], root[v2], root[lca2], root[plca2], 1, 100000, k)

		fmt.Fprintf(out, "%d", len(ans))
		for _, v := range ans {
			fmt.Fprintf(out, " %d", v)
		}
		fmt.Fprintln(out)
	}
}