For problem statement at 0-999/700-799/760-769/762/problemF.txt this is a correct solution, but verifier at 0-999/700-799/760-769/762/verifierF.go ends with All tests passed. can you fix the verifier? package main

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

const MOD = 1000000007

func power(base, exp int) int {
	res := 1
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

func modInverse(n int) int {
	return power(n, MOD-2)
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(reader, &n); err != nil {
		return
	}

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

	var m int
	if _, err := fmt.Fscan(reader, &m); err != nil {
		return
	}

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

	children := make([][]int, m+1)
	var dfsT func(u, p int)
	dfsT = func(u, p int) {
		for _, v := range adjT[u] {
			if v != p {
				children[u] = append(children[u], v)
				dfsT(v, u)
			}
		}
	}
	dfsT(1, 0)

	solve := func(targetAdj [][]int) int {
		targetNodes := len(targetAdj) - 1
		memo := make(map[int]int)

		var dp func(x, u, p int) int
		dp = func(x, u, p int) int {
			state := (x * 2000000) + (p * 2000) + u
			if val, exists := memo[state]; exists {
				return val
			}

			C := children[x]
			k := len(C)

			var N []int
			for _, v := range targetAdj[u] {
				if v != p {
					N = append(N, v)
				}
			}
			if k > len(N) {
				memo[state] = 0
				return 0
			}

			match_dp := make([]int, 1<<k)
			match_dp[0] = 1

			for _, v := range N {
				next_dp := make([]int, 1<<k)
				copy(next_dp, match_dp)
				for mask := 0; mask < (1 << k); mask++ {
					if match_dp[mask] == 0 {
						continue
					}
					for i := 0; i < k; i++ {
						if (mask & (1 << i)) == 0 {
							nmask := mask | (1 << i)
							val := dp(C[i], v, u)
							next_dp[nmask] = (next_dp[nmask] + match_dp[mask]*val) % MOD
						}
					}
				}
				match_dp = next_dp
			}

			ans := match_dp[(1<<k)-1]
			memo[state] = ans
			return ans
		}

		total := 0
		for u := 1; u <= targetNodes; u++ {
			total = (total + dp(1, u, 0)) % MOD
		}
		return total
	}

	totalS := solve(adjS)
	totalAut := solve(adjT)

	ans := (totalS * modInverse(totalAut)) % MOD
	fmt.Println(ans)
}