For problem statement at 1000-1999/1900-1999/1900-1909/1909/problemC.txt this is a correct solution, but verifier at 1000-1999/1900-1999/1900-1909/1909/verifierC.go ends with case 2 failed: expected 1436 got 1502
input:
1
4
8 24 46 37 
22 36 52 51 
3 25 69 58 
exit status 1 can you fix the verifier? package main

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

type Fenwick struct {
	n   int
	bit []int64
}

func NewFenwick(n int) *Fenwick {
	return &Fenwick{n: n, bit: make([]int64, n+1)}
}
func (f *Fenwick) Add(i int, delta int64) {
	for i <= f.n {
		f.bit[i] += delta
		i += i & -i
	}
}
func (f *Fenwick) Sum(i int) int64 {
	var res int64
	for i > 0 {
		res += f.bit[i]
		i -= i & -i
	}
	return res
}
func (f *Fenwick) RangeSum(l, r int) int64 {
	if r < l {
		return 0
	}
	return f.Sum(r) - f.Sum(l-1)
}

func lowerBound(a []int, x int) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] < x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

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

	var t int
	fmt.Fscan(in, &t)
	for ; t > 0; t-- {
		var n int
		fmt.Fscan(in, &n)
		l := make([]int, n)
		r := make([]int, n)
		c := make([]int64, n)
		all := make([]int, 0, 2*n)
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &l[i])
			all = append(all, l[i])
		}
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &r[i])
			all = append(all, r[i])
		}
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &c[i])
		}

		sort.Ints(all)
		m := len(all)

		minSide := make([]int, 0, n)
		maxSide := make([]int, 0, n)
		for i := 0; i < n; i++ {
			li := l[i]
			ri := r[i]
			if li < ri {
				minSide = append(minSide, li)
				maxSide = append(maxSide, ri)
			} else {
				minSide = append(minSide, ri)
				maxSide = append(maxSide, li)
			}
		}

		sort.Ints(minSide)
		sort.Ints(maxSide)

		fwCnt := NewFenwick(m)
		fwSum := NewFenwick(m)
		for _, v := range maxSide {
			idx := lowerBound(all, v) + 1
			fwCnt.Add(idx, 1)
			fwSum.Add(idx, int64(v))
		}

		lengths := make([]int64, n)
		for i := 0; i < n; i++ {
			x := minSide[i]
			idxX := lowerBound(all, x) + 1

			totalCnt := fwCnt.Sum(m)
			preCnt := fwCnt.Sum(idxX)

			var y int
			if preCnt == totalCnt {
				y = maxSide[i]
			} else {
				k := preCnt + 1
				lb, rb := 1, m
				for lb < rb {
					md := (lb + rb) >> 1
					if fwCnt.Sum(md) >= k {
						rb = md
					} else {
						lb = md + 1
					}
				}
				y = all[lb-1]
			}

			idxY := lowerBound(all, y) + 1
			fwCnt.Add(idxY, -1)
			fwSum.Add(idxY, -int64(y))

			lengths[i] = int64(y - x)
		}

		sort.Slice(lengths, func(i, j int) bool { return lengths[i] < lengths[j] })
		sort.Slice(c, func(i, j int) bool { return c[i] > c[j] })

		var ans int64
		for i := 0; i < n; i++ {
			ans += lengths[i] * c[i]
		}
		fmt.Fprintln(out, ans)
	}
}