For problem statement at 1000-1999/1100-1199/1110-1119/1111/problemD.txt this is a correct solution, but verifier at 1000-1999/1100-1199/1110-1119/1111/verifierD.go ends with All 100 tests passed. can you fix the verifier? ```go
package main

import (
	"bufio"
	"os"
)

const MOD = 1000000007

func power(base, exp int64) int64 {
	res := int64(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 int64) int64 {
	return power(n, MOD-2)
}

func charIdx(c byte) int {
	if c >= 'a' && c <= 'z' {
		return int(c - 'a')
	}
	return int(c - 'A') + 26
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 2*1024*1024)
	scanner.Buffer(buf, 2*1024*1024)

	if !scanner.Scan() {
		return
	}
	s := scanner.Bytes()
	n := len(s)
	if n == 0 {
		return
	}

	if !scanner.Scan() {
		return
	}
	q := 0
	for _, b := range scanner.Bytes() {
		q = q*10 + int(b-'0')
	}

	freq := make([]int, 52)
	for i := 0; i < n; i++ {
		freq[charIdx(s[i])]++
	}

	fact := make([]int64, n+1)
	invFact := make([]int64, n+1)
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= n; i++ {
		fact[i] = fact[i-1] * int64(i) % MOD
	}
	invFact[n] = modInverse(fact[n])
	for i := n - 1; i >= 1; i-- {
		invFact[i] = invFact[i+1] * int64(i+1) % MOD
	}

	dp := make([]int64, n/2+1)
	dp[0] = 1

	var types []int
	for i := 0; i < 52; i++ {
		if freq[i] > 0 {
			types = append(types, i)
			f := freq[i]
			for w := n / 2; w >= f; w-- {
				dp[w] = (dp[w] + dp[w-f])
				if dp[w] >= MOD {
					dp[w] -= MOD
				}
			}
		}
	}

	K := fact[n/2] * fact[n/2] % MOD
	for i := 0; i < 52; i++ {
		if freq[i] > 0 {
			K = K * invFact[freq[i]] % MOD
		}
	}

	ans := make([][]int64, 52)
	for i := 0; i < 52; i++ {
		ans[i] = make([]int64, 52)
	}

	baseAns := K * dp[n/2] % MOD
	for i := 0; i < 52; i++ {
		ans[i][i] = baseAns
	}

	for _, i := range types {
		fi := freq[i]
		dpi := make([]int64, n/2+1)
		copy(dpi, dp)
		for w := fi; w <= n/2; w++ {
			dpi[w] = dpi[w] - dpi[w-fi]
			if dpi[w] < 0 {
				dpi[w] += MOD
			}
		}

		for _, j := range types {
			if i >= j {
				continue
			}
			fj := freq[j]
			M := n/2 - fi - fj
			if M < 0 {
				ans[i][j] = 0
				ans[j][i] = 0
				continue
			}

			sum := int64(0)
			for w := M; w >= 0; w -= 2 * fj {
				sum += dpi[w]
			}
			for w := M - fj; w >= 0; w -= 2 * fj {
				sum -= dpi[w]
			}
			sum %= MOD
			if sum < 0 {
				sum += MOD
			}

			res := (2 * K % MOD) * sum % MOD
			ans[i][j] = res
			ans[j][i] = res
		}
	}

	var outBuf []byte
	var b [20]byte

	for k := 0; k < q; k++ {
		scanner.Scan()
		x := 0
		for _, bt := range scanner.Bytes() {
			x = x*10 + int(bt-'0')
		}
		scanner.Scan()
		y := 0
		for _, bt := range scanner.Bytes() {
			y = y*10 + int(bt-'0')
		}

		x--
		y--
		u := charIdx(s[x])
		v := charIdx(s[y])
		res := ans[u][v]

		if res == 0 {
			outBuf = append(outBuf, '0', '\n')
		} else {
			idx := 20
			for res > 0 {
				idx--
				b[idx] = byte(res%10 + '0')
				res /= 10
			}
			outBuf = append(outBuf, b[idx:]...)
			outBuf = append(outBuf, '\n')
		}
	}
	os.Stdout.Write(outBuf)
}
```