For problem statement at 1000-1999/1800-1899/1840-1849/1841/problemF.txt this is a correct solution, but verifier at 1000-1999/1800-1899/1840-1849/1841/verifierF.go ends with case 2 failed: expected:
17.0000000000
got:
13
input:
3
4 0 1 2
1 2 2 2
0 2 2 0
exit status 1 can you fix the verifier? package main

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

type FastScanner struct {
	data []byte
	idx  int
}

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

func (fs *FastScanner) NextInt64() int64 {
	n := len(fs.data)
	for fs.idx < n && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
	sign := int64(1)
	if fs.idx < n && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var val int64
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int64(c-'0')
		fs.idx++
	}
	return sign * val
}

type Vec struct {
	x, y int64
}

func half(v Vec) bool {
	return v.y > 0 || (v.y == 0 && v.x > 0)
}

func cross(a, b Vec) int64 {
	return a.x*b.y - a.y*b.x
}

func dot(a, b Vec) int64 {
	return a.x*b.x + a.y*b.y
}

func inSemi(a, b Vec) bool {
	c := cross(a, b)
	if c != 0 {
		return c > 0
	}
	return dot(a, b) > 0
}

func absu(x int64) uint64 {
	if x < 0 {
		return uint64(-x)
	}
	return uint64(x)
}

func norm2(x, y int64) (uint64, uint64) {
	ux := absu(x)
	uy := absu(y)
	hi1, lo1 := bits.Mul64(ux, ux)
	hi2, lo2 := bits.Mul64(uy, uy)
	lo, carry := bits.Add64(lo1, lo2, 0)
	hi := hi1 + hi2 + carry
	return hi, lo
}

func greater(ahi, alo, bhi, blo uint64) bool {
	return ahi > bhi || (ahi == bhi && alo > blo)
}

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

	n := int(in.NextInt64())
	vecs := make([]Vec, 0, n)

	for i := 0; i < n; i++ {
		a := in.NextInt64()
		b := in.NextInt64()
		c := in.NextInt64()
		d := in.NextInt64()
		x := a - b
		y := c - d
		if x != 0 || y != 0 {
			vecs = append(vecs, Vec{x, y})
		}
	}

	m := len(vecs)
	if m == 0 {
		fmt.Fprintln(out, 0)
		return
	}

	sort.Slice(vecs, func(i, j int) bool {
		hi := half(vecs[i])
		hj := half(vecs[j])
		if hi != hj {
			return hi && !hj
		}
		return cross(vecs[i], vecs[j]) > 0
	})

	all := make([]Vec, 2*m)
	copy(all, vecs)
	copy(all[m:], vecs)

	var sumX, sumY int64
	j := 0
	var bestHi, bestLo uint64

	for i := 0; i < m; i++ {
		if j < i {
			j = i
			sumX, sumY = 0, 0
		}
		for j < i+m && inSemi(all[i], all[j]) {
			sumX += all[j].x
			sumY += all[j].y
			j++
		}
		hi, lo := norm2(sumX, sumY)
		if greater(hi, lo, bestHi, bestLo) {
			bestHi, bestLo = hi, lo
		}
		sumX -= all[i].x
		sumY -= all[i].y
	}

	ans := new(big.Int).SetUint64(bestHi)
	ans.Lsh(ans, 64)
	ans.Add(ans, new(big.Int).SetUint64(bestLo))
	fmt.Fprintln(out, ans.String())
}