For problem statement at 1000-1999/1400-1499/1400-1409/1408/problemG.txt this is a correct solution, but verifier at 1000-1999/1400-1499/1400-1409/1408/verifierG.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"fmt"
	"io"
	"os"
	"slices"
)

type Edge struct {
	u, v int
	w    int
}

func main() {
	buf, _ := io.ReadAll(os.Stdin)
	var pos int
	readInt := func() int {
		for pos < len(buf) && (buf[pos] < '0' || buf[pos] > '9') {
			pos++
		}
		if pos >= len(buf) {
			return 0
		}
		res := 0
		for pos < len(buf) && buf[pos] >= '0' && buf[pos] <= '9' {
			res = res*10 + int(buf[pos]-'0')
			pos++
		}
		return res
	}

	n := readInt()
	if n == 0 {
		return
	}
	if n == 1 {
		fmt.Println(1)
		return
	}

	edges := make([]Edge, 0, n*(n-1)/2)
	for i := 1; i <= n; i++ {
		for j := 1; j <= n; j++ {
			w := readInt()
			if i < j {
				edges = append(edges, Edge{u: i, v: j, w: w})
			}
		}
	}

	slices.SortFunc(edges, func(a, b Edge) int {
		return a.w - b.w
	})

	parent := make([]int, n+1)
	size := make([]int, n+1)
	edgesCount := make([]int, n+1)
	maxSets := make([][]int, n+1)

	for i := 1; i <= n; i++ {
		parent[i] = i
		size[i] = 1
		edgesCount[i] = 0
		maxSets[i] = []int{i}
	}

	var find func(int) int
	find = func(i int) int {
		root := i
		for root != parent[root] {
			root = parent[root]
		}
		curr := i
		for curr != root {
			nxt := parent[curr]
			parent[curr] = root
			curr = nxt
		}
		return root
	}

	tree := make([][]int, 2*n)
	nextNodeID := n + 1

	for _, e := range edges {
		ru := find(e.u)
		rv := find(e.v)

		if ru != rv {
			parent[rv] = ru
			size[ru] += size[rv]
			edgesCount[ru] += edgesCount[rv] + 1
			maxSets[ru] = append(maxSets[ru], maxSets[rv]...)
		} else {
			edgesCount[ru]++
		}

		sz := size[ru]
		if edgesCount[ru] == sz*(sz-1)/2 {
			newNodeID := nextNodeID
			nextNodeID++
			tree[newNodeID] = maxSets[ru]
			maxSets[ru] = []int{newNodeID}
		}
	}

	dp := make([][]int, nextNodeID)
	for i := 1; i <= n; i++ {
		dp[i] = []int{0, 1}
	}

	const MOD = 998244353

	for i := n + 1; i < nextNodeID; i++ {
		poly := []int{1}
		for _, v := range tree[i] {
			childPoly := dp[v]
			newPoly := make([]int, len(poly)+len(childPoly)-1)
			for j, c1 := range poly {
				if c1 == 0 {
					continue
				}
				for k, c2 := range childPoly {
					if c2 == 0 {
						continue
					}
					newPoly[j+k] = (newPoly[j+k] + c1*c2) % MOD
				}
			}
			poly = newPoly
		}
		if len(poly) <= 1 {
			newPoly := make([]int, 2)
			copy(newPoly, poly)
			poly = newPoly
		}
		poly[1] = (poly[1] + 1) % MOD
		dp[i] = poly
	}

	root := nextNodeID - 1
	ans := dp[root]

	for k := 1; k <= n; k++ {
		if k < len(ans) {
			fmt.Print(ans[k])
		} else {
			fmt.Print(0)
		}
		if k < n {
			fmt.Print(" ")
		}
	}
	fmt.Println()
}
```