For problem statement at 0-999/200-299/240-249/249/problemE.txt this is a correct solution, but verifier at 0-999/200-299/240-249/249/verifierE.go ends with All tests passed can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"math/big"
	"os"
)

func maxBig(a, b *big.Int) *big.Int {
	if a.Cmp(b) > 0 {
		return new(big.Int).Set(a)
	}
	return new(big.Int).Set(b)
}

func minBig(a, b *big.Int) *big.Int {
	if a.Cmp(b) < 0 {
		return new(big.Int).Set(a)
	}
	return new(big.Int).Set(b)
}

func sum1(n *big.Int) *big.Int {
	if n.Sign() <= 0 {
		return big.NewInt(0)
	}
	nn := new(big.Int).Add(n, big.NewInt(1))
	res := new(big.Int).Mul(n, nn)
	res.Div(res, big.NewInt(2))
	return res
}

func sum2(n *big.Int) *big.Int {
	if n.Sign() <= 0 {
		return big.NewInt(0)
	}
	nn := new(big.Int).Add(n, big.NewInt(1))
	nn2 := new(big.Int).Mul(big.NewInt(2), n)
	nn2.Add(nn2, big.NewInt(1))
	res := new(big.Int).Mul(n, nn)
	res.Mul(res, nn2)
	res.Div(res, big.NewInt(6))
	return res
}

func sum3(n *big.Int) *big.Int {
	if n.Sign() <= 0 {
		return big.NewInt(0)
	}
	tmp := sum1(n)
	return new(big.Int).Mul(tmp, tmp)
}

func rangeSum1(a, b *big.Int) *big.Int {
	if b.Cmp(a) < 0 {
		return big.NewInt(0)
	}
	return new(big.Int).Sub(sum1(b), sum1(new(big.Int).Sub(a, big.NewInt(1))))
}

func rangeSum2(a, b *big.Int) *big.Int {
	if b.Cmp(a) < 0 {
		return big.NewInt(0)
	}
	return new(big.Int).Sub(sum2(b), sum2(new(big.Int).Sub(a, big.NewInt(1))))
}

func rangeSum3(a, b *big.Int) *big.Int {
	if b.Cmp(a) < 0 {
		return big.NewInt(0)
	}
	return new(big.Int).Sub(sum3(b), sum3(new(big.Int).Sub(a, big.NewInt(1))))
}

func computeSum(L, R, B, T *big.Int) *big.Int {
	total := big.NewInt(0)

	// Low part
	lowPart1 := big.NewInt(0)
	a1 := maxBig(L, B)
	z1 := minBig(R, T)
	if a1.Cmp(z1) <= 0 {
		kStart := new(big.Int).Sub(a1, big.NewInt(1))
		kEnd := new(big.Int).Sub(z1, big.NewInt(1))
		sumK3 := rangeSum3(kStart, kEnd)
		sumK2 := rangeSum2(kStart, kEnd)
		twoMinusB := new(big.Int).Sub(big.NewInt(2), B)
		part1 := new(big.Int).Add(sumK3, new(big.Int).Mul(twoMinusB, sumK2))

		sumI2 := rangeSum2(a1, z1)
		sumI := rangeSum1(a1, z1)
		tmp := new(big.Int).Add(sumI2, sumI)
		sumOfSumupto := new(big.Int).Div(tmp, big.NewInt(2))

		bm1 := new(big.Int).Sub(B, big.NewInt(1))
		c := sum1(bm1)
		numI := new(big.Int).Add(new(big.Int).Sub(z1, a1), big.NewInt(1))
		subtract := new(big.Int).Mul(numI, c)

		lowPart1.Add(part1, sumOfSumupto)
		lowPart1.Sub(lowPart1, subtract)
	}

	lowPart2 := big.NewInt(0)
	tp1 := new(big.Int).Add(T, big.NewInt(1))
	a2 := maxBig(L, tp1)
	z2 := new(big.Int).Set(R)
	if a2.Cmp(z2) <= 0 {
		constNum := new(big.Int).Add(new(big.Int).Sub(T, B), big.NewInt(1))
		if constNum.Sign() < 0 {
			constNum.SetInt64(0)
		}
		constSumj := rangeSum1(B, T)

		kStart := new(big.Int).Sub(a2, big.NewInt(1))
		kEnd := new(big.Int).Sub(z2, big.NewInt(1))
		sumK2 := rangeSum2(kStart, kEnd)
		part2a := new(big.Int).Mul(constNum, sumK2)

		numI2 := new(big.Int).Add(new(big.Int).Sub(z2, a2), big.NewInt(1))
		part2b := new(big.Int).Mul(numI2, constSumj)

		lowPart2.Add(part2a, part2b)
	}

	total.Add(lowPart1, lowPart2)

	// High part
	highPartSmall := big.NewInt(0)
	a4 := maxBig(L, big.NewInt(1))
	z4tmp1 := minBig(R, new(big.Int).Sub(B, big.NewInt(1)))
	z4 := minBig(z4tmp1, new(big.Int).Sub(T, big.NewInt(1)))
	if a4.Cmp(z4) <= 0 {
		constNumH := new(big.Int).Add(new(big.Int).Sub(T, B), big.NewInt(1))
		bm1h := new(big.Int).Sub(B, big.NewInt(1))
		tm1 := new(big.Int).Sub(T, big.NewInt(1))
		const1 := rangeSum2(bm1h, tm1)
		sumjH := rangeSum1(B, T)
		const2 := new(big.Int).Mul(big.NewInt(2), sumjH)
		constSum := new(big.Int).Add(const1, const2)

		numI4 := new(big.Int).Add(new(big.Int).Sub(z4, a4), big.NewInt(1))
		part4a := new(big.Int).Mul(numI4, constSum)

		sumI4 := rangeSum1(a4, z4)
		part4b := new(big.Int).Mul(constNumH, sumI4)

		highPartSmall.Sub(part4a, part4b)
	}

	highPartVar := big.NewInt(0)
	a3 := maxBig(L, B)
	z3 := minBig(R, new(big.Int).Sub(T, big.NewInt(1)))
	if a3.Cmp(z3) <= 0 {
		m := new(big.Int).Sub(T, big.NewInt(1))

		// (j-1)^2 part
		oneMinusA3 := new(big.Int).Sub(big.NewInt(1), a3)
		sumK3Var := rangeSum3(a3, z3)
		sumK2Var := rangeSum2(a3, z3)
		varPart := new(big.Int).Add(sumK3Var, new(big.Int).Mul(oneMinusA3, sumK2Var))

		bp1 := new(big.Int).Add(z3, big.NewInt(1))
		constPart := big.NewInt(0)
		if bp1.Cmp(m) <= 0 {
			constNumK := new(big.Int).Add(new(big.Int).Sub(z3, a3), big.NewInt(1))
			constSumK2 := rangeSum2(bp1, m)
			constPart = new(big.Int).Mul(constNumK, constSumK2)
		}
		totalForSq := new(big.Int).Add(varPart, constPart)

		// 2 * sum j part
		s := new(big.Int).Add(a3, big.NewInt(1))
		u := new(big.Int).Add(z3, big.NewInt(1))
		varPartJ := big.NewInt(0)
		if s.Cmp(u) <= 0 {
			sumJ2Varj := rangeSum2(s, u)
			sumJVarj := rangeSum1(s, u)
			varPartJ.Sub(sumJ2Varj, new(big.Int).Mul(a3, sumJVarj))
		}

		up1 := new(big.Int).Add(z3, big.NewInt(2))
		constPartJ := big.NewInt(0)
		if up1.Cmp(T) <= 0 {
			constNumJ := new(big.Int).Add(new(big.Int).Sub(z3, a3), big.NewInt(1))
			constSumJ := rangeSum1(up1, T)
			constPartJ = new(big.Int).Mul(constNumJ, constSumJ)
		}
		totalForJ := new(big.Int).Add(varPartJ, constPartJ)
		totalFor2j := new(big.Int).Mul(big.NewInt(2), totalForJ)

		// - sum i (T - i)
		sumI3 := rangeSum1(a3, z3)
		sumI3MulT := new(big.Int).Mul(T, sumI3)
		sumI23 := rangeSum2(a3, z3)
		itPart := new(big.Int).Sub(sumI23, sumI3MulT)

		highPartVar.Add(totalForSq, totalFor2j)
		highPartVar.Add(highPartVar, itPart)
	}

	total.Add(total, highPartSmall)
	total.Add(total, highPartVar)
	return total
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	var t int
	fmt.Fscan(reader, &t)
	for i := 0; i < t; i++ {
		var x1, y1, x2, y2 int64
		fmt.Fscan(reader, &x1, &y1, &x2, &y2)
		L := big.NewInt(x1)
		R := big.NewInt(x2)
		Bb := big.NewInt(y1)
		Tt := big.NewInt(y2)
		summ := computeSum(L, R, Bb, Tt)
		str := summ.String()
		if len(str) <= 10 {
			fmt.Println(str)
		} else {
			fmt.Println("..." + str[len(str)-10:])
		}
	}
}
```