For problem statement at 1000-1999/1000-1099/1030-1039/1039/problemD.txt this is a correct solution, but verifier at 1000-1999/1000-1099/1030-1039/1039/verifierD.go ends with wrong answer on test 8
input:
8
1 2
1 3
2 4
2 5
1 6
3 7
6 8

expected:
8
3
2
1
1
0
0
0
got:
8
3
2
0
1
0
0
0

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

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

var (
	n         int
	children  [][]int
	postOrder []int
	up        []int
	seen      []bool
	added     []int
	memo      []int
)

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	fmt.Fscan(in, &n)
	adj := make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		var u, v int
		fmt.Fscan(in, &u, &v)
		adj[u] = append(adj[u], v)
		adj[v] = append(adj[v], u)
	}

	children = make([][]int, n+1)
	parent := make([]int, n+1)
	bfsOrder := make([]int, 0, n)
	queue := []int{1}
	parent[1] = 0
	for len(queue) > 0 {
		u := queue[0]
		queue = queue[1:]
		bfsOrder = append(bfsOrder, u)
		for _, v := range adj[u] {
			if v != parent[u] {
				parent[v] = u
				children[u] = append(children[u], v)
				queue = append(queue, v)
			}
		}
	}
	postOrder = make([]int, n)
	for i, u := range bfsOrder {
		postOrder[n-1-i] = u
	}

	up = make([]int, n+1)
	seen = make([]bool, n+1)
	added = make([]int, n+1)
	memo = make([]int, n+1)
	for i := range memo {
		memo[i] = -1
	}

	compute := func(k int) int {
		if memo[k] != -1 {
			return memo[k]
		}
		addedPtr := 0
		ans := 0
		for _, u := range postOrder {
			maxUp := 0
			found := false
			startAdded := addedPtr
			for _, v := range children[u] {
				val := up[v]
				if val != 0 {
					if !found {
						comp := k - 1 - val
						if seen[comp] {
							found = true
							break
						}
						seen[val] = true
						added[addedPtr] = val
						addedPtr++
					}
					if val > maxUp {
						maxUp = val
					}
				}
			}
			if found {
				ans++
				up[u] = 0
			} else {
				if maxUp+1 == k {
					ans++
					up[u] = 0
				} else {
					up[u] = maxUp + 1
				}
			}
			for i := startAdded; i < addedPtr; i++ {
				seen[added[i]] = false
			}
			addedPtr = startAdded
		}
		memo[k] = ans
		return ans
	}

	B := int(math.Sqrt(float64(n)))*3 + 1
	if B > n {
		B = n
	}

	ansArray := make([]int, n+1)
	for k := 1; k <= B; k++ {
		ansArray[k] = compute(k)
	}

	if B < n {
		k := B + 1
		for k <= n {
			val := compute(k)
			ansArray[k] = val
			if val == 0 {
				for i := k + 1; i <= n; i++ {
					ansArray[i] = 0
				}
				break
			}
			lo := k + 1
			hi := n
			last := k
			for lo <= hi {
				mid := (lo + hi) / 2
				if compute(mid) == val {
					last = mid
					lo = mid + 1
				} else {
					hi = mid - 1
				}
			}
			for i := k + 1; i <= last; i++ {
				ansArray[i] = val
			}
			k = last + 1
		}
	}

	for i := 1; i <= n; i++ {
		fmt.Fprintln(out, ansArray[i])
	}
}
```