For problem statement at 0-999/400-499/490-499/493/problemE.txt this is a correct solution, but verifier at 0-999/400-499/490-499/493/verifierE.go ends with All tests passed can you fix the verifier? package main

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

const MOD int64 = 1000000007

var tVal, aVal, den int64
var powT, powA []int64

func digitSumBase(n, base int64) int64 {
	var s int64
	for n > 0 {
		s += n % base
		n /= base
	}
	return s
}

func linearCount(remA, remB int64) int64 {
	num := remB - remA
	if num%den != 0 {
		return 0
	}
	c1 := num / den
	if c1 < 0 {
		return 0
	}
	c0 := remA - c1*tVal
	if c0 < 0 {
		return 0
	}
	return 1
}

func tailCount(remA, remB int64) int64 {
	num := remB - remA
	if num%den != 0 {
		return 0
	}
	k := num / den
	if k < 0 {
		return 0
	}
	high := k / (aVal + tVal)
	low := int64(0)
	need := tVal*k - remA
	if need > 0 {
		d := tVal * aVal
		low = (need + d - 1) / d
	}
	if low > high {
		return 0
	}
	return (high - low + 1) % MOD
}

func dfs(i int, remA, remB int64) int64 {
	if i < 2 {
		return linearCount(remA, remB)
	}
	if i == 2 {
		return tailCount(remA, remB)
	}
	maxc := remA / powT[i]
	if x := remB / powA[i]; x < maxc {
		maxc = x
	}
	var ans int64
	pt := powT[i]
	pa := powA[i]
	for c := int64(0); c <= maxc; c++ {
		ans += dfs(i-1, remA-c*pt, remB-c*pa)
		if ans >= MOD {
			ans -= MOD
		}
	}
	return ans
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var t, a, b int64
	fmt.Fscan(in, &t, &a, &b)

	if t == 1 {
		if a == 1 {
			if b == 1 {
				fmt.Fprint(out, "inf")
			} else {
				fmt.Fprint(out, 0)
			}
			return
		}
		s := digitSumBase(b, a)
		if s == a || (s == 1 && b >= a) {
			fmt.Fprint(out, 1)
		} else {
			fmt.Fprint(out, 0)
		}
		return
	}

	if a == t {
		if b == a {
			fmt.Fprint(out, 2)
		} else {
			fmt.Fprint(out, 0)
		}
		return
	}

	tVal = t
	aVal = a
	den = a - t

	num := b - a
	if num%den != 0 || num/den < 0 {
		fmt.Fprint(out, 0)
		return
	}

	powT = []int64{1}
	powA = []int64{1}
	N := 0
	curT, curA := int64(1), int64(1)
	for i := 1; i < 64; i++ {
		if curT > a/t {
			curT = a + 1
		} else {
			curT *= t
		}
		if curA > b/a {
			curA = b + 1
		} else {
			curA *= a
		}
		powT = append(powT, curT)
		powA = append(powA, curA)
		if curT <= a && curA <= b {
			N = i
		} else {
			break
		}
	}

	fmt.Fprint(out, dfs(N, a, b)%MOD)
}