For problem statement at 0-999/700-799/770-779/773/problemF.txt this is a correct solution, but verifier at 0-999/700-799/770-779/773/verifierF.go ends with mismatch on test 1: expected 0 got 466
exit status 1 can you fix the verifier? package main

import (
	"fmt"
)

func modInverse(a, m int64) int64 {
	m0, x0, x1 := m, int64(0), int64(1)
	if m == 1 {
		return 0
	}
	for a > 1 {
		q := a / m
		a, m = m, a%m
		x0, x1 = x1-q*x0, x0
	}
	if x1 < 0 {
		x1 += m0
	}
	return x1
}

func power(base, exp, mod 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 main() {
	var maxn, maxa, q int64
	if _, err := fmt.Scan(&maxn, &maxa, &q); err != nil {
		return
	}

	tempQ := q
	a := int64(0)
	for tempQ%2 == 0 {
		a++
		tempQ /= 2
	}
	b := tempQ

	var primes []int64
	temp := q
	for i := int64(2); i*i <= temp; i++ {
		if temp%i == 0 {
			primes = append(primes, i)
			for temp%i == 0 {
				temp /= i
			}
		}
	}
	if temp > 1 {
		primes = append(primes, temp)
	}

	var inv2b int64
	if b > 1 {
		inv2b = modInverse(2, b)
	}

	K := (maxn - 1) / 2
	ans := int64(0)

	for j := int64(1); ; j++ {
		pow2 := int64(1) << j
		if pow2 > maxa {
			break
		}
		X := maxa / pow2
		if X < 1 {
			break
		}
		N := (X - 1) / 2
		if N < 0 {
			continue
		}

		n := 2*N + 2
		maxK := 2*K + a + 1
		binom := make([]int64, maxK+1)
		binom[0] = 1
		V := int64(1)
		E := make([]int64, len(primes))

		for i := int64(1); i <= maxK; i++ {
			if i > n {
				binom[i] = 0
				continue
			}
			num := n - i + 1
			den := i

			for idx, p := range primes {
				for num%p == 0 {
					num /= p
					E[idx]++
				}
				for den%p == 0 {
					den /= p
					E[idx]--
				}
			}

			V = (V * (num % q)) % q
			inv_den := modInverse(den%q, q)
			V = (V * inv_den) % q

			val := V
			for idx, p := range primes {
				if E[idx] > 0 {
					val = (val * power(p, E[idx], q)) % q
				}
			}
			binom[i] = val
		}

		mk := make([]int64, 2*K+a+1)
		for i := int64(0); i <= 2*K+a; i++ {
			mk[i] = binom[i+1]
		}

		Sb := int64(0)
		if b > 1 {
			Q_prev := int64(0)
			for k := int64(0); k <= 2*K; k++ {
				m_val := mk[k] % b
				Qk := (m_val - Q_prev) % b
				if Qk < 0 {
					Qk += b
				}
				Qk = (Qk * inv2b) % b
				if k%2 == 0 {
					Sb = (Sb + Qk) % b
				}
				Q_prev = Qk
			}
		}

		Sa := int64(0)
		if a > 0 {
			modA := int64(1) << a
			for i := int64(0); i <= K; i++ {
				k := 2 * i
				Qk := int64(0)
				for j := int64(1); j <= a; j++ {
					term := mk[k+j] % modA
					term = (term * (int64(1) << (j - 1))) % modA
					if (j-1)%2 == 1 {
						Qk = (Qk - term) % modA
					} else {
						Qk = (Qk + term) % modA
					}
				}
				if Qk < 0 {
					Qk = (Qk%modA + modA) % modA
				}
				Sa = (Sa + Qk) % modA
			}
		}

		var ansN int64
		if a == 0 {
			ansN = Sb % q
		} else if b == 1 {
			ansN = Sa % q
		} else {
			modA := int64(1) << a
			invB := modInverse(b%modA, modA)
			invA := modInverse(modA%b, b)
			term1 := (((Sa * b) % q) * invB) % q
			term2 := (((Sb * modA) % q) * invA) % q
			ansN = (term1 + term2) % q
		}

		ans = (ans + ansN) % q
	}

	fmt.Println(ans)
}