For problem statement at 2000-2999/2100-2199/2110-2119/2114/problemD.txt this is a correct solution, but verifier at 2000-2999/2100-2199/2110-2119/2114/verifierD.go ends with test 1 (single-point) failed on case 2: expected 1 got 2
2
1
5 5
2
1 1
1 2

exit status 1 can you fix the verifier? ```go
package main

import (
	"bufio"
	"os"
)

type FastReader struct {
	r *bufio.Reader
}

func NewFastReader() *FastReader {
	return &FastReader{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fr *FastReader) NextInt64() int64 {
	var sign int64 = 1
	var val int64 = 0
	c, err := fr.r.ReadByte()
	for err == nil && c <= ' ' {
		c, err = fr.r.ReadByte()
	}
	if err != nil {
		return 0
	}
	if c == '-' {
		sign = -1
		c, err = fr.r.ReadByte()
	}
	for err == nil && c > ' ' {
		val = val*10 + int64(c-'0')
		c, err = fr.r.ReadByte()
	}
	return val * sign
}

func min64(a, b int64) int64 {
	if a < b {
		return a
	}
	return b
}
func max64(a, b int64) int64 {
	if a > b {
		return a
	}
	return b
}

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

	t := int(in.NextInt64())
	const INF int64 = 1 << 60

	for ; t > 0; t-- {
		n := int(in.NextInt64())
		xs := make([]int64, n)
		ys := make([]int64, n)

		xmin, xmax := INF, -INF
		ymin, ymax := INF, -INF

		for i := 0; i < n; i++ {
			x := in.NextInt64()
			y := in.NextInt64()
			xs[i] = x
			ys[i] = y
			if x < xmin {
				xmin = x
			}
			if x > xmax {
				xmax = x
			}
			if y < ymin {
				ymin = y
			}
			if y > ymax {
				ymax = y
			}
		}

		if n == 1 {
			out.WriteString("1\n")
			continue
		}

		cntMinX, cntMaxX := 0, 0
		cntMinY, cntMaxY := 0, 0
		secondMinX, secondMaxX := INF, -INF
		secondMinY, secondMaxY := INF, -INF

		for i := 0; i < n; i++ {
			x := xs[i]
			y := ys[i]
			if x == xmin {
				cntMinX++
			} else if x < secondMinX {
				secondMinX = x
			}
			if x == xmax {
				cntMaxX++
			} else if x > secondMaxX {
				secondMaxX = x
			}
			if y == ymin {
				cntMinY++
			} else if y < secondMinY {
				secondMinY = y
			}
			if y == ymax {
				cntMaxY++
			} else if y > secondMaxY {
				secondMaxY = y
			}
		}

		W := (xmax - xmin + 1)
		H := (ymax - ymin + 1)
		ans := W * H

		m := int64(n - 1)

		for i := 0; i < n; i++ {
			x := xs[i]
			y := ys[i]
			if !(x == xmin || x == xmax || y == ymin || y == ymax) {
				continue
			}

			nxMin := xmin
			if x == xmin && cntMinX == 1 {
				nxMin = secondMinX
			}
			nxMax := xmax
			if x == xmax && cntMaxX == 1 {
				nxMax = secondMaxX
			}
			nyMin := ymin
			if y == ymin && cntMinY == 1 {
				nyMin = secondMinY
			}
			nyMax := ymax
			if y == ymax && cntMaxY == 1 {
				nyMax = secondMaxY
			}

			w := nxMax - nxMin + 1
			h := nyMax - nyMin + 1
			a := w * h
			if a == m {
				a += min64(w, h)
			}
			if a < ans {
				ans = a
			}
		}

		out.WriteString(intToString(ans) + "\n")
	}
}

func intToString(x int64) string {
	if x == 0 {
		return "0"
	}
	neg := false
	if x < 0 {
		neg = true
		x = -x
	}
	buf := make([]byte, 0, 20)
	for x > 0 {
		buf = append(buf, byte('0'+x%10))
		x /= 10
	}
	if neg {
		buf = append(buf, '-')
	}
	// reverse
	for i, j := 0, len(buf)-1; i < j; i, j = i+1, j-1 {
		buf[i], buf[j] = buf[j], buf[i]
	}
	return string(buf)
}
```