For problem statement at 1000-1999/1300-1399/1390-1399/1394/problemD.txt this is a correct solution, but verifier at 1000-1999/1300-1399/1390-1399/1394/verifierD.go ends with mismatch on test 9
expected: 298
 got: 316

exit status 1 can you fix the verifier? ```go
package main

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

var scanner *bufio.Scanner

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

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

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

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

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

	in := make([]int, n+1)
	out := make([]int, n+1)
	adj := make([][]int, n+1)

	for i := 1; i <= n-1; i++ {
		u := nextInt()
		v := nextInt()
		if h[u] < h[v] {
			out[u]++
			in[v]++
		} else if h[u] > h[v] {
			in[u]++
			out[v]++
		} else {
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}
	}

	visited := make([]bool, n+1)
	var dfs func(u, p int) [3]int64
	dfs = func(u, p int) [3]int64 {
		visited[u] = true
		var children []int
		for _, v := range adj[u] {
			if v != p {
				children = append(children, v)
			}
		}

		var baseSum int64 = 0
		deltas := make([]int64, 0, len(children))

		for _, v := range children {
			res := dfs(v, u)
			baseSum += res[0]
			deltas = append(deltas, res[1]-res[0])
		}

		sort.Slice(deltas, func(i, j int) bool {
			return deltas[i] < deltas[j]
		})

		var dp [3]int64
		for S := 0; S <= 2; S++ {
			if p == 0 && S != 2 {
				continue
			}
			if p != 0 && S == 2 {
				continue
			}

			fixedIn := in[u]
			if S == 1 {
				fixedIn++
			}
			fixedOut := out[u]
			if S == 0 {
				fixedOut++
			}

			var minCost int64 = 2e18
			k := len(children)
			currDeltaSum := int64(0)

			for j := 0; j <= k; j++ {
				inU := fixedIn + k - j
				outU := fixedOut + j

				maxInOut := inU
				if outU > maxInOut {
					maxInOut = outU
				}

				costU := int64(t[u]) * int64(maxInOut)
				total := baseSum + currDeltaSum + costU

				if total < minCost {
					minCost = total
				}

				if j < k {
					currDeltaSum += deltas[j]
				}
			}
			dp[S] = minCost
		}
		return dp
	}

	var totalCost int64 = 0
	for i := 1; i <= n; i++ {
		if !visited[i] {
			res := dfs(i, 0)
			totalCost += res[2]
		}
	}

	fmt.Println(totalCost)
}
```