For problem statement at 1000-1999/1900-1999/1910-1919/1912/problemB.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1910-1919/1912/verifierB.go ends with All 80 tests passed can you fix the verifier? ```go
package main

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

const MOD int64 = 998244353

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) nextInt64() int64 {
	var sign int64 = 1
	var val int64 = 0
	c, _ := fs.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, _ = fs.r.ReadByte()
	}
	if c == '-' {
		sign = -1
		c, _ = fs.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int64(c-'0')
		c2, err := fs.r.ReadByte()
		if err != nil {
			break
		}
		c = c2
	}
	return val * sign
}

func modPow(a, e int64) int64 {
	res := int64(1)
	for e > 0 {
		if e&1 == 1 {
			res = res * a % MOD
		}
		a = a * a % MOD
		e >>= 1
	}
	return res
}

func prepareFac(maxN int) ([]int64, []int64) {
	fac := make([]int64, maxN+1)
	ifac := make([]int64, maxN+1)
	fac[0] = 1
	for i := 1; i <= maxN; i++ {
		fac[i] = fac[i-1] * int64(i) % MOD
	}
	ifac[maxN] = modPow(fac[maxN], MOD-2)
	for i := maxN; i >= 1; i-- {
		ifac[i-1] = ifac[i] * int64(i) % MOD
	}
	return fac, ifac
}

func comb(n, k int, fac, ifac []int64) int64 {
	if k < 0 || k > n || n < 0 {
		return 0
	}
	return fac[n] * ifac[k] % MOD * ifac[n-k] % MOD
}

func coeffTri(m, i int, fac, ifac []int64) int64 {
	if i < 0 || i > 2*m {
		return 0
	}
	low := 0
	if i-m > low {
		low = i - m
	}
	high := i / 2
	if high > m {
		high = m
	}
	var res int64 = 0
	for c := low; c <= high; c++ {
		// C(m, c) * C(m-c, i-2c)
		res += comb(m, c, fac, ifac) * comb(m-c, i-2*c, fac, ifac) % MOD
		if res >= MOD {
			res -= MOD
		}
	}
	return res
}

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

	t := int(in.nextInt64())
	ns := make([]int64, t)
	ks := make([]int, t)
	maxK := 0
	for i := 0; i < t; i++ {
		ns[i] = in.nextInt64()
		ks[i] = int(in.nextInt64())
		if ks[i] > maxK {
			maxK = ks[i]
		}
	}
	fac, ifac := prepareFac(maxK)

	for i := 0; i < t; i++ {
		n := ns[i]
		k := ks[i]
		R := n - int64(k+1)
		var D int64
		var r int64
		var minCost int64
		if R <= int64(k-1) {
			D = 0
			r = R
			minCost = 0
			// ways = coeff of (1+z)^{k-1} at z^r = C(k-1, r)
			ways := comb(k-1, int(r), fac, ifac)
			fmt.Fprintf(out, "%d %d\n", minCost, ways%MOD)
			continue
		} else {
			num := R - int64(k-1)
			den := int64(2 * k)
			D = (num + den - 1) / den
			L := int64(2*k)*D - int64(k+1)
			r = R - L
			minCost = int64(k)*D*(D-1) + r*D
		}
		m := k - 1
		// ways = coeff of (1+z)^2 * (1+z+z^2)^{m} at z^r
		c0 := coeffTri(m, int(r), fac, ifac)
		c1 := coeffTri(m, int(r-1), fac, ifac)
		c2 := coeffTri(m, int(r-2), fac, ifac)
		ways := (c0 + 2*c1 + c2) % MOD
		fmt.Fprintf(out, "%d %d\n", minCost, ways)
	}
}
```