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 All 200 tests passed can you fix the verifier? package main

import (
	"bufio"
	"fmt"
	"io"
	"math/bits"
	"os"
)

const (
	B    = 30
	MaxK = 1 << B
	MOD  = 1000000007
)

var (
	n          int
	m          int64
	vals       []uint32
	child0     []int32
	child1     []int32
	cnt        []uint16
	ones       []uint16
	totalPairs int64
	totalSum   int64
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt() int {
	for fs.idx < len(fs.data) && (fs.data[fs.idx] < '0' || fs.data[fs.idx] > '9') {
		fs.idx++
	}
	val := 0
	for fs.idx < len(fs.data) && fs.data[fs.idx] >= '0' && fs.data[fs.idx] <= '9' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func buildTrie() {
	maxNodes := n*B + 2
	child0 = make([]int32, maxNodes)
	child1 = make([]int32, maxNodes)
	cnt = make([]uint16, maxNodes)
	ones = make([]uint16, maxNodes*B)

	nodes := 1
	for _, x := range vals {
		var pos [B]int
		pc := 0
		v := x
		for v != 0 {
			j := bits.TrailingZeros32(v)
			pos[pc] = j
			pc++
			v &= v - 1
		}

		node := 1
		cnt[node]++
		base := node * B
		for i := 0; i < pc; i++ {
			ones[base+pos[i]]++
		}

		for b := B - 1; b >= 0; b-- {
			if (x>>uint(b))&1 == 0 {
				next := int(child0[node])
				if next == 0 {
					nodes++
					next = nodes
					child0[node] = int32(next)
				}
				node = next
			} else {
				next := int(child1[node])
				if next == 0 {
					nodes++
					next = nodes
					child1[node] = int32(next)
				}
				node = next
			}
			cnt[node]++
			base = node * B
			for i := 0; i < pc; i++ {
				ones[base+pos[i]]++
			}
		}
	}
}

func countLess(k int) int64 {
	if k <= 0 {
		return 0
	}
	if k >= MaxK {
		return totalPairs
	}
	var total int64
	for _, x := range vals {
		node := 1
		var c int64
		for b := B - 1; b >= 0 && node != 0; b-- {
			kb := (k >> uint(b)) & 1
			xb := (x >> uint(b)) & 1
			if kb == 1 {
				if xb == 0 {
					cnode := int(child0[node])
					if cnode != 0 {
						c += int64(cnt[cnode])
					}
					node = int(child1[node])
				} else {
					cnode := int(child1[node])
					if cnode != 0 {
						c += int64(cnt[cnode])
					}
					node = int(child0[node])
				}
			} else {
				if xb == 0 {
					node = int(child0[node])
				} else {
					node = int(child1[node])
				}
			}
		}
		total += c
	}
	return (total - int64(n)) / 2
}

func xorSumNode(idx int, x uint32) int64 {
	c := int64(cnt[idx])
	base := idx * B
	var s int64
	xx := x
	for j := 0; j < B; j++ {
		o := int64(ones[base+j])
		if xx&1 == 0 {
			s += o << uint(j)
		} else {
			s += (c - o) << uint(j)
		}
		xx >>= 1
	}
	return s
}

func countSumLess(k int) (int64, int64) {
	if k <= 0 {
		return 0, 0
	}
	if k >= MaxK {
		return totalPairs, totalSum
	}
	var totalC, totalS int64
	for _, x := range vals {
		node := 1
		var c, s int64
		for b := B - 1; b >= 0 && node != 0; b-- {
			kb := (k >> uint(b)) & 1
			xb := (x >> uint(b)) & 1
			if kb == 1 {
				if xb == 0 {
					cnode := int(child0[node])
					if cnode != 0 {
						c += int64(cnt[cnode])
						s += xorSumNode(cnode, x)
					}
					node = int(child1[node])
				} else {
					cnode := int(child1[node])
					if cnode != 0 {
						c += int64(cnt[cnode])
						s += xorSumNode(cnode, x)
					}
					node = int(child0[node])
				}
			} else {
				if xb == 0 {
					node = int(child0[node])
				} else {
					node = int(child1[node])
				}
			}
		}
		totalC += c
		totalS += s
	}
	return (totalC - int64(n)) / 2, totalS / 2
}

func main() {
	fs := NewFastScanner()
	n = fs.NextInt()
	m = int64(fs.NextInt())

	vals = make([]uint32, n)
	var bitOnes [B]int64
	for i := 0; i < n; i++ {
		x := uint32(fs.NextInt())
		vals[i] = x
		v := x
		for v != 0 {
			j := bits.TrailingZeros32(v)
			bitOnes[j]++
			v &= v - 1
		}
	}

	if m == 0 {
		w := bufio.NewWriterSize(os.Stdout, 1<<20)
		fmt.Fprintln(w, 0)
		w.Flush()
		return
	}

	totalPairs = int64(n) * int64(n-1) / 2
	for j := 0; j < B; j++ {
		o := bitOnes[j]
		z := int64(n) - o
		totalSum += o * z * (int64(1) << uint(j))
	}

	buildTrie()

	low, high := 0, MaxK-1
	for low < high {
		mid := low + (high-low+1)/2
		if totalPairs-countLess(mid) >= m {
			low = mid
		} else {
			high = mid - 1
		}
	}
	t := low

	lessCount, lessSum := countSumLess(t + 1)
	cntGreater := totalPairs - lessCount
	sumGreater := totalSum - lessSum

	ans := sumGreater + (m-cntGreater)*int64(t)

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	fmt.Fprintln(w, ans%MOD)
	w.Flush()
}