For problem statement at 0-999/200-299/240-249/241/problemB.txt this is a correct solution, but verifier at 0-999/200-299/240-249/241/verifierB.go ends with test 1 failed: expected 25 got 22

exit status 1 can you fix the verifier? package main

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

const MOD int64 = 1000000007
const MAXB = 30

var (
	n, m int
	a    []int
	pref [MAXB + 1][]int
	pow2 [MAXB + 1]int64
)

func binFirstOne(l, r, bit int) int {
	mask := 1 << bit
	lo, hi := l, r
	for lo < hi {
		m := (lo + hi) >> 1
		if (a[m] & mask) == 0 {
			lo = m + 1
		} else {
			hi = m
		}
	}
	return lo
}

func onesInRange(bit, l, r int) int {
	return pref[bit][r] - pref[bit][l]
}

func sumAllWithin(l, r, bit int) (int64, int64) {
	sz := r - l
	if sz < 2 || bit < 0 {
		return 0, 0
	}
	cnt := int64(sz*(sz-1)) / 2
	var sum int64 = 0
	for j := 0; j <= bit; j++ {
		ones := int64(onesInRange(j, l, r))
		zeros := int64(sz) - ones
		sum += ones * zeros * pow2[j]
	}
	return cnt, sum
}

func sumAllCross(l1, r1, l2, r2, bit int) (int64, int64) {
	n1 := r1 - l1
	n2 := r2 - l2
	if n1 == 0 || n2 == 0 || bit < 0 {
		return 0, 0
	}
	cnt := int64(n1) * int64(n2)
	var sum int64 = 0
	for j := 0; j <= bit; j++ {
		onesA := int64(onesInRange(j, l1, r1))
		onesB := int64(onesInRange(j, l2, r2))
		zerosA := int64(n1) - onesA
		zerosB := int64(n2) - onesB
		sum += (onesA*zerosB + zerosA*onesB) * pow2[j]
	}
	return cnt, sum
}

func dfsCross(l1, r1, l2, r2, bit, K int) (int64, int64) {
	if l1 >= r1 || l2 >= r2 || bit < 0 {
		return 0, 0
	}
	mid1 := binFirstOne(l1, r1, bit)
	mid2 := binFirstOne(l2, r2, bit)
	if ((K>>bit)&1) == 0 {
		c1, s1 := dfsCross(l1, mid1, l2, mid2, bit-1, K)
		c2, s2 := dfsCross(mid1, r1, mid2, r2, bit-1, K)
		return c1 + c2, s1 + s2
	} else {
		c1, s1 := sumAllCross(l1, mid1, l2, mid2, bit-1)
		c2, s2 := sumAllCross(mid1, r1, mid2, r2, bit-1)
		c3, s3 := dfsCross(l1, mid1, mid2, r2, bit-1, K)
		c4, s4 := dfsCross(mid1, r1, l2, mid2, bit-1, K)
		return c1 + c2 + c3 + c4, s1 + s2 + s3 + s4
	}
}

func dfsWithin(l, r, bit, K int) (int64, int64) {
	sz := r - l
	if sz < 2 || bit < 0 {
		return 0, 0
	}
	mid := binFirstOne(l, r, bit)
	if ((K>>bit)&1) == 0 {
		c1, s1 := dfsWithin(l, mid, bit-1, K)
		c2, s2 := dfsWithin(mid, r, bit-1, K)
		return c1 + c2, s1 + s2
	} else {
		c1, s1 := sumAllWithin(l, mid, bit-1)
		c2, s2 := sumAllWithin(mid, r, bit-1)
		c3, s3 := dfsCross(l, mid, mid, r, bit-1, K)
		return c1 + c2 + c3, s1 + s2 + s3
	}
}

func computeLess(K int, totalPairs int64, sumAll int64) (int64, int64) {
	if K <= 0 {
		return 0, 0
	}
	if K >= (1 << MAXB) {
		return totalPairs, sumAll
	}
	return dfsWithin(0, n, MAXB-1, K)
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	if _, err := fmt.Fscan(in, &n, &m); err != nil {
		return
	}
	a = make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &a[i])
	}
	sort.Ints(a)

	for j := 0; j <= MAXB; j++ {
		pref[j] = make([]int, n+1)
		for i := 0; i < n; i++ {
			pref[j][i+1] = pref[j][i]
			if ((a[i] >> j) & 1) == 1 {
				pref[j][i+1]++
			}
		}
		pow2[j] = int64(1) << uint(j)
	}

	totalPairs := int64(n*(n-1)) / 2
	var sumAll int64 = 0
	for j := 0; j <= MAXB-1; j++ {
		ones := int64(pref[j][n])
		zeros := int64(n) - ones
		sumAll += ones * zeros * pow2[j]
	}

	if m == 0 {
		fmt.Fprintln(out, 0)
		return
	}
	if int64(m) == totalPairs {
		fmt.Fprintln(out, ((sumAll%MOD)+MOD)%MOD)
		return
	}

	kSmall := totalPairs - int64(m)

	lo, hi := 0, 1<<31
	for lo < hi {
		mid := (lo + hi) >> 1
		cnt, _ := computeLess(mid, totalPairs, sumAll)
		if cnt >= kSmall {
			hi = mid
		} else {
			lo = mid + 1
		}
	}
	Tplus1 := lo
	T := Tplus1 - 1

	var sumSmall int64
	if kSmall == 0 {
		sumSmall = 0
	} else {
		cntLT, sumLT := computeLess(T, totalPairs, sumAll)
		remain := kSmall - cntLT
		sumSmall = sumLT + remain*int64(T)
	}

	ans := (sumAll - sumSmall) % MOD
	if ans < 0 {
		ans += MOD
	}
	fmt.Fprintln(out, ans)
}