For problem statement at 1000-1999/1600-1699/1680-1689/1689/problemC.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1680-1689/1689/verifierC.go ends with test 16 failed
input:
1
10
1 2
2 3
1 4
1 5
5 6
5 7
2 8
4 9
7 10
expected: 2
got: 3

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

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) nextInt() int {
	sign := 1
	val := 0
	c, _ := fs.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, _ = fs.r.ReadByte()
	}
	if c == '-' {
		sign = -1
		c, _ = fs.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int(c-'0')
		c2, err := fs.r.ReadByte()
		if err != nil {
			break
		}
		c = c2
	}
	return sign * val
}

func main() {
	in := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

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

		// Build rooted tree at 1
		children := make([][]int, n+1)
		parent := make([]int, n+1)
		vis := make([]bool, n+1)
		order := make([]int, 0, n)

		stack := make([]int, 0, n)
		stack = append(stack, 1)
		vis[1] = true
		parent[1] = 0
		for len(stack) > 0 {
			u := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			order = append(order, u)
			for _, w := range adj[u] {
				if vis[w] {
					continue
				}
				vis[w] = true
				parent[w] = u
				children[u] = append(children[u], w)
				stack = append(stack, w)
			}
		}

		// Subtree sizes
		sub := make([]int, n+1)
		for i := len(order) - 1; i >= 0; i-- {
			u := order[i]
			s := 1
			for _, v := range children[u] {
				s += sub[v]
			}
			sub[u] = s
		}

		// Simulate infection by layers, deleting one best child each round
		saved := 0
		cur := []int{1}
		for len(cur) > 0 {
			next := make([]int, 0)
			for _, u := range cur {
				for _, v := range children[u] {
					next = append(next, v)
				}
			}
			if len(next) == 0 {
				break
			}
			// choose child with maximum subtree size to delete
			maxIdx := 0
			maxSz := sub[next[0]]
			for i := 1; i < len(next); i++ {
				if sub[next[i]] > maxSz {
					maxSz = sub[next[i]]
					maxIdx = i
				}
			}
			saved += maxSz - 1
			// build next infected excluding the deleted one
			newCur := make([]int, 0, len(next)-1)
			for i, v := range next {
				if i == maxIdx {
					continue
				}
				newCur = append(newCur, v)
			}
			cur = newCur
		}

		fmt.Fprintln(out, saved)
	}
}
```