For problem statement at 2000-2999/2000-2099/2000-2009/2004/problemF.txt this is a correct solution, but verifier at 2000-2999/2000-2099/2000-2009/2004/verifierF.go ends with All 9 tests passed. can you fix the verifier? package main

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

type FastScanner struct {
	r   *bufio.Reader
	buf []byte
}

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

func (fs *FastScanner) NextInt() int64 {
	sign := int64(1)
	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')
		c, _ = fs.r.ReadByte()
	}
	return val * sign
}

type Pair struct {
	sum int64
	i   int32
	j   int32
}
type Query struct {
	sum int64
	A   int32
	B   int32
	w   int16
}

type Fenwick struct {
	n   int
	t   []int32
	ver []int32
	cur int32
}

func NewFenwick(n int) *Fenwick {
	return &Fenwick{
		n:   n,
		t:   make([]int32, n+2),
		ver: make([]int32, n+2),
		cur: 1,
	}
}
func (f *Fenwick) Reset() {
	f.cur++
}
func (f *Fenwick) add(pos int, delta int32) {
	for p := pos; p <= f.n; p += p & -p {
		if f.ver[p] != f.cur {
			f.t[p] = 0
			f.ver[p] = f.cur
		}
		f.t[p] += delta
	}
}
func (f *Fenwick) sum(pos int) int32 {
	var res int32 = 0
	for p := pos; p > 0; p -= p & -p {
		if f.ver[p] == f.cur {
			res += f.t[p]
		}
	}
	return res
}

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

	t := int(fs.NextInt())
	for ; t > 0; t-- {
		n := int(fs.NextInt())
		a := make([]int64, n)
		for i := 0; i < n; i++ {
			a[i] = fs.NextInt()
		}
		pref := make([]int64, n+1)
		for i := 0; i < n; i++ {
			pref[i+1] = pref[i] + a[i]
		}

		// Build pairs (i,j) with sums K = pref[i] + pref[j]
		nPairs := (n + 1) * n / 2
		pairs := make([]Pair, 0, nPairs)
		for i := 0; i <= n-1; i++ {
			pi := pref[i]
			for j := i + 1; j <= n; j++ {
				pairs = append(pairs, Pair{sum: pi + pref[j], i: int32(i), j: int32(j)})
			}
		}

		// Build queries
		// For y in [1..n-1]
		// y==t: K=2*pref[y], A=y-1, B=y+1, w=1
		// y<t:  K=pref[y]+pref[t], A=y-1, B=t+1, w=2
		nQueries := (n - 1) * n / 2
		queries := make([]Query, 0, nQueries)
		for y := 1; y <= n-1; y++ {
			K := pref[y] * 2
			queries = append(queries, Query{sum: K, A: int32(y - 1), B: int32(y + 1), w: 1})
			for t2 := y + 1; t2 <= n-1; t2++ {
				K2 := pref[y] + pref[t2]
				queries = append(queries, Query{sum: K2, A: int32(y - 1), B: int32(t2 + 1), w: 2})
			}
		}

		sort.Slice(pairs, func(i, j int) bool {
			if pairs[i].sum != pairs[j].sum {
				return pairs[i].sum < pairs[j].sum
			}
			if pairs[i].i != pairs[j].i {
				return pairs[i].i < pairs[j].i
			}
			return pairs[i].j < pairs[j].j
		})
		sort.Slice(queries, func(i, j int) bool {
			if queries[i].sum != queries[j].sum {
				return queries[i].sum < queries[j].sum
			}
			if queries[i].A != queries[j].A {
				return queries[i].A < queries[j].A
			}
			return queries[i].B < queries[j].B
		})

		var ansC int64 = 0
		fw := NewFenwick(n + 2)
		pPtr := 0
		qPtr := 0
		for pPtr < len(pairs) {
			curK := pairs[pPtr].sum
			pEnd := pPtr
			for pEnd < len(pairs) && pairs[pEnd].sum == curK {
				pEnd++
			}
			for qPtr < len(queries) && queries[qPtr].sum < curK {
				qPtr++
			}
			qEnd := qPtr
			for qEnd < len(queries) && queries[qEnd].sum == curK {
				qEnd++
			}
			if qEnd > qPtr {
				fw.Reset()
				var inserted int32 = 0
				p := pPtr
				for qi := qPtr; qi < qEnd; qi++ {
					A := queries[qi].A
					for p < pEnd && pairs[p].i <= A {
						j := int(pairs[p].j)
						pos := j + 1
						fw.add(pos, 1)
						inserted++
						p++
					}
					B := int(queries[qi].B)
					cnt := inserted - fw.sum(B)
					ansC += int64(cnt) * int64(queries[qi].w)
				}
			}
			pPtr = pEnd
			qPtr = qEnd
		}

		var total1 int64 = 0
		for d := 1; d <= n-1; d++ {
			total1 += int64(d) * int64(n-d)
		}
		ans := total1 - ansC
		if ans < 0 {
			ans = 0
		}
		// Print answer
		out.WriteString(Int64ToString(ans))
		out.WriteByte('\n')
	}
}

func Int64ToString(x int64) string {
	if x == 0 {
		return "0"
	}
	var b [32]byte
	i := len(b)
	neg := x < 0
	if neg {
		x = -x
	}
	for x > 0 {
		i--
		b[i] = byte('0' + x%10)
		x /= 10
	}
	if neg {
		i--
		b[i] = '-'
	}
	return string(b[i:])
}