For problem statement at 0-999/600-699/600-609/601/problemD.txt this is a correct solution, but verifier at 0-999/600-699/600-609/601/verifierD.go ends with case 40 failed: expected 14
1 got 13
1
input:
6
8 5 5 4 0 7
accbac
1 2
1 3
2 4
3 5
2 6
exit status 1 can you fix the verifier? ```go
package main

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

type Node struct {
	children [26]int32
	size     int32
}

var nodes []Node

func merge(a, b int32) int32 {
	if a == 0 {
		return b
	}
	if b == 0 {
		return a
	}
	nodes[a].size = 1
	for i := 0; i < 26; i++ {
		if nodes[a].children[i] == 0 {
			nodes[a].children[i] = nodes[b].children[i]
		} else if nodes[b].children[i] != 0 {
			nodes[a].children[i] = merge(nodes[a].children[i], nodes[b].children[i])
		}
		if nodes[a].children[i] != 0 {
			nodes[a].size += nodes[nodes[a].children[i]].size
		}
	}
	return a
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)

	var n int
	fmt.Fscan(in, &n)

	if n == 0 {
		return
	}

	c := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		fmt.Fscan(in, &c[i])
	}

	var s string
	fmt.Fscan(in, &s)

	head := make([]int32, n+1)
	next := make([]int32, 2*n)
	to := make([]int32, 2*n)
	var edgeCnt int32

	addEdge := func(u, v int32) {
		edgeCnt++
		next[edgeCnt] = head[u]
		to[edgeCnt] = v
		head[u] = edgeCnt
	}

	for i := 1; i < n; i++ {
		var u, v int32
		fmt.Fscan(in, &u, &v)
		addEdge(u, v)
		addEdge(v, u)
	}

	nodes = make([]Node, n+1)
	dif := make([]int32, n+1)

	order := make([]int32, 0, n)
	q := make([]int32, 0, n)
	parent := make([]int32, n+1)

	q = append(q, 1)
	for len(q) > 0 {
		u := q[0]
		q = q[1:]
		order = append(order, u)
		for e := head[u]; e != 0; e = next[e] {
			v := to[e]
			if v != parent[u] {
				parent[v] = u
				q = append(q, v)
			}
		}
	}

	for i := len(order) - 1; i >= 0; i-- {
		u := order[i]
		nodes[u].size = 1
		for e := head[u]; e != 0; e = next[e] {
			v := to[e]
			if v != parent[u] {
				charIdx := s[v-1] - 'a'
				nodes[u].children[charIdx] = merge(nodes[u].children[charIdx], v)
			}
		}
		nodes[u].size = 1
		for j := 0; j < 26; j++ {
			if nodes[u].children[j] != 0 {
				nodes[u].size += nodes[nodes[u].children[j]].size
			}
		}
		dif[u] = nodes[u].size
	}

	var maxVal int64 = -1
	var count int

	for i := 1; i <= n; i++ {
		val := int64(dif[i]) + c[i]
		if val > maxVal {
			maxVal = val
			count = 1
		} else if val == maxVal {
			count++
		}
	}

	fmt.Printf("%d\n%d\n", maxVal, count)
}
```