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

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

type Event struct {
	dx, dy int64
	sx, sy int64
}

func half(x, y int64) int {
	if y > 0 || (y == 0 && x >= 0) {
		return 0
	}
	return 1
}

func angleLess(ax, ay, bx, by int64) bool {
	ha, hb := half(ax, ay), half(bx, by)
	if ha != hb {
		return ha < hb
	}
	c := ax*by - ay*bx
	if c != 0 {
		return c > 0
	}
	if ax != bx {
		return ax < bx
	}
	return ay < by
}

func sameAngle(ax, ay, bx, by int64) bool {
	return half(ax, ay) == half(bx, by) && ax*by-ay*bx == 0
}

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

func norm128(x, y int64) (uint64, uint64) {
	ax, ay := absU(x), absU(y)
	hi1, lo1 := bits.Mul64(ax, ax)
	hi2, lo2 := bits.Mul64(ay, ay)
	lo := lo1 + lo2
	hi := hi1 + hi2
	if lo < lo1 {
		hi++
	}
	return hi, lo
}

func better(h1, l1, h2, l2 uint64) bool {
	return h1 > h2 || (h1 == h2 && l1 > l2)
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	readInt := func() int64 {
		for idx < len(data) && data[idx] <= ' ' {
			idx++
		}
		sign := int64(1)
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		var v int64
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			v = v*10 + int64(data[idx]-'0')
			idx++
		}
		return sign * v
	}

	n := int(readInt())
	events := make([]Event, 0, 2*n)
	var curX, curY int64

	for i := 0; i < n; i++ {
		a := readInt()
		b := readInt()
		c := readInt()
		d := readInt()

		x := a - b
		y := c - d
		if x == 0 && y == 0 {
			continue
		}

		if half(x, y) == 0 {
			curX += x
			curY += y
		}

		events = append(events, Event{dx: x, dy: y, sx: -x, sy: -y})
		events = append(events, Event{dx: -x, dy: -y, sx: x, sy: y})
	}

	bestHi, bestLo := norm128(curX, curY)

	if len(events) > 0 {
		sort.Slice(events, func(i, j int) bool {
			return angleLess(events[i].dx, events[i].dy, events[j].dx, events[j].dy)
		})

		for i := 0; i < len(events); {
			j := i
			var addX, addY int64
			dx, dy := events[i].dx, events[i].dy
			for j < len(events) && sameAngle(dx, dy, events[j].dx, events[j].dy) {
				addX += events[j].sx
				addY += events[j].sy
				j++
			}
			curX += addX
			curY += addY
			hi, lo := norm128(curX, curY)
			if better(hi, lo, bestHi, bestLo) {
				bestHi, bestLo = hi, lo
			}
			i = j
		}
	}

	var ans big.Int
	ans.SetUint64(bestHi)
	ans.Lsh(&ans, 64)
	var low big.Int
	low.SetUint64(bestLo)
	ans.Add(&ans, &low)

	out := bufio.NewWriter(os.Stdout)
	fmt.Fprint(out, ans.String())
	out.Flush()
}