For problem statement at 2000-2999/2000-2099/2040-2049/2046/problemC.txt this is a correct solution, but verifier at 2000-2999/2000-2099/2040-2049/2046/verifierC.go ends with All 6 tests passed can you fix the verifier? package main

import (
	"bufio"
	"bytes"
	"io"
	"os"
	"sort"
	"strconv"
)

type Point struct {
	x int
	y int
}

type Fenwick struct {
	n      int
	bit    []int
	maxPow int
}

func NewFenwick(n int) *Fenwick {
	p := 1
	for p < n {
		p <<= 1
	}
	return &Fenwick{
		n:      n,
		bit:    make([]int, n+1),
		maxPow: p,
	}
}

func (f *Fenwick) Clear() {
	for i := range f.bit {
		f.bit[i] = 0
	}
}

func (f *Fenwick) Build(freq []int) {
	copy(f.bit, freq)
	for i := 1; i <= f.n; i++ {
		j := i + (i & -i)
		if j <= f.n {
			f.bit[j] += f.bit[i]
		}
	}
}

func (f *Fenwick) Add(i, delta int) {
	for i <= f.n {
		f.bit[i] += delta
		i += i & -i
	}
}

func (f *Fenwick) Kth(k int) int {
	idx := 0
	b := f.maxPow
	for b > 0 {
		next := idx + b
		if next <= f.n && f.bit[next] < k {
			idx = next
			k -= f.bit[next]
		}
		b >>= 1
	}
	return idx + 1
}

type Solver struct {
	points []Point
	ys     []int
	freq   []int
	left   *Fenwick
	right  *Fenwick
	n      int
}

func (s *Solver) Check(k int) (bool, int, int) {
	if k == 0 {
		return true, 0, 0
	}
	if 4*k > s.n {
		return false, 0, 0
	}
	s.left.Clear()
	s.right.Build(s.freq)

	leftCount := 0
	i := 0
	for i < s.n {
		x0 := s.points[i].x
		rightCount := s.n - leftCount

		if leftCount >= 2*k && rightCount >= 2*k {
			lowL := s.ys[s.left.Kth(k)-1]
			highL := s.ys[s.left.Kth(leftCount-k+1)-1]
			lowR := s.ys[s.right.Kth(k)-1]
			highR := s.ys[s.right.Kth(rightCount-k+1)-1]

			low := lowL
			if lowR > low {
				low = lowR
			}
			high := highL
			if highR < high {
				high = highR
			}

			if low+1 <= high {
				return true, x0, low + 1
			}
		}

		for i < s.n && s.points[i].x == x0 {
			id := s.points[i].y
			s.left.Add(id, 1)
			s.right.Add(id, -1)
			leftCount++
			i++
		}
	}

	return false, 0, 0
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) {
			c := data[idx]
			if c > ' ' {
				break
			}
			idx++
		}
		sign := 1
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		val := 0
		for idx < len(data) {
			c := data[idx]
			if c < '0' || c > '9' {
				break
			}
			val = val*10 + int(c-'0')
			idx++
		}
		return sign * val
	}

	t := nextInt()
	var out bytes.Buffer

	for ; t > 0; t-- {
		n := nextInt()
		points := make([]Point, n)
		ys := make([]int, n)
		for i := 0; i < n; i++ {
			x := nextInt()
			y := nextInt()
			points[i] = Point{x: x, y: y}
			ys[i] = y
		}

		sort.Ints(ys)
		m := 0
		for _, v := range ys {
			if m == 0 || ys[m-1] != v {
				ys[m] = v
				m++
			}
		}
		ys = ys[:m]

		freq := make([]int, m+1)
		for i := 0; i < n; i++ {
			id := sort.SearchInts(ys, points[i].y) + 1
			points[i].y = id
			freq[id]++
		}

		sort.Slice(points, func(i, j int) bool {
			return points[i].x < points[j].x
		})

		s := Solver{
			points: points,
			ys:     ys,
			freq:   freq,
			left:   NewFenwick(m),
			right:  NewFenwick(m),
			n:      n,
		}

		ansK, ansX, ansY := 0, 0, 0
		l, r := 1, n/4
		for l <= r {
			mid := (l + r) >> 1
			ok, x0, y0 := s.Check(mid)
			if ok {
				ansK, ansX, ansY = mid, x0, y0
				l = mid + 1
			} else {
				r = mid - 1
			}
		}

		out.WriteString(strconv.Itoa(ansK))
		out.WriteByte('\n')
		if ansK == 0 {
			out.WriteString("0 0\n")
		} else {
			out.WriteString(strconv.Itoa(ansX))
			out.WriteByte(' ')
			out.WriteString(strconv.Itoa(ansY))
			out.WriteByte('\n')
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out.Bytes())
	w.Flush()
}