For problem statement at 0-999/200-299/270-279/277/problemC.txt this is a correct solution, but verifier at 0-999/200-299/270-279/277/verifierC.go ends with case 4 failed
input:5 5 2
1 4 4 4
2 1 2 1
expected:FIRST
0 1 3 1
got:FIRST
2 0 2 3
exit status 1 can you fix the verifier? ```go
package main

import (
	"fmt"
	"io"
	"os"
	"sort"
)

type Interval struct {
	start, end int64
}

func main() {
	buf, _ := io.ReadAll(os.Stdin)
	pos := 0

	readInt := func() int64 {
		for pos < len(buf) && buf[pos] <= ' ' {
			pos++
		}
		if pos >= len(buf) {
			return 0
		}
		res := int64(0)
		for pos < len(buf) && buf[pos] > ' ' {
			res = res*10 + int64(buf[pos]-'0')
			pos++
		}
		return res
	}

	n := readInt()
	if n == 0 {
		return
	}
	m := readInt()
	k := readInt()

	vertCuts := make(map[int64][]Interval)
	horizCuts := make(map[int64][]Interval)

	for i := int64(0); i < k; i++ {
		xb := readInt()
		yb := readInt()
		xe := readInt()
		ye := readInt()

		if xb == xe {
			minY, maxY := yb, ye
			if minY > maxY {
				minY, maxY = maxY, minY
			}
			vertCuts[xb] = append(vertCuts[xb], Interval{minY, maxY})
		} else {
			minX, maxX := xb, xe
			if minX > maxX {
				minX, maxX = maxX, minX
			}
			horizCuts[yb] = append(horizCuts[yb], Interval{minX, maxX})
		}
	}

	X := int64(0)
	if (n-1)%2 != 0 {
		X ^= m
	}
	if (m-1)%2 != 0 {
		X ^= n
	}

	vertUncut := make(map[int64][]Interval)
	vertV := make(map[int64]int64)

	for x, intervals := range vertCuts {
		sort.Slice(intervals, func(i, j int) bool {
			if intervals[i].start == intervals[j].start {
				return intervals[i].end < intervals[j].end
			}
			return intervals[i].start < intervals[j].start
		})

		var merged []Interval
		currStart := int64(-1)
		currEnd := int64(-1)

		for _, p := range intervals {
			if currEnd < p.start {
				if currStart != -1 {
					merged = append(merged, Interval{currStart, currEnd})
				}
				currStart = p.start
				currEnd = p.end
			} else {
				if p.end > currEnd {
					currEnd = p.end
				}
			}
		}
		if currStart != -1 {
			merged = append(merged, Interval{currStart, currEnd})
		}

		C := int64(0)
		for _, p := range merged {
			C += p.end - p.start
		}

		Vx := m - C
		
		var uncut []Interval
		last := int64(0)
		for _, p := range merged {
			if p.start > last {
				uncut = append(uncut, Interval{last, p.start})
			}
			last = p.end
		}
		if last < m {
			uncut = append(uncut, Interval{last, m})
		}

		vertUncut[x] = uncut
		vertV[x] = Vx

		X ^= m
		X ^= Vx
	}

	horizUncut := make(map[int64][]Interval)
	horizV := make(map[int64]int64)

	for y, intervals := range horizCuts {
		sort.Slice(intervals, func(i, j int) bool {
			if intervals[i].start == intervals[j].start {
				return intervals[i].end < intervals[j].end
			}
			return intervals[i].start < intervals[j].start
		})

		var merged []Interval
		currStart := int64(-1)
		currEnd := int64(-1)

		for _, p := range intervals {
			if currEnd < p.start {
				if currStart != -1 {
					merged = append(merged, Interval{currStart, currEnd})
				}
				currStart = p.start
				currEnd = p.end
			} else {
				if p.end > currEnd {
					currEnd = p.end
				}
			}
		}
		if currStart != -1 {
			merged = append(merged, Interval{currStart, currEnd})
		}

		C := int64(0)
		for _, p := range merged {
			C += p.end - p.start
		}

		Hy := n - C

		var uncut []Interval
		last := int64(0)
		for _, p := range merged {
			if p.start > last {
				uncut = append(uncut, Interval{last, p.start})
			}
			last = p.end
		}
		if last < n {
			uncut = append(uncut, Interval{last, n})
		}

		horizUncut[y] = uncut
		horizV[y] = Hy

		X ^= n
		X ^= Hy
	}

	if X == 0 {
		fmt.Println("SECOND")
		return
	}

	fmt.Println("FIRST")

	for x, Vx := range vertV {
		if (Vx ^ X) < Vx {
			target := Vx - (Vx ^ X)
			uncut := vertUncut[x]
			A := uncut[0].start
			sum := int64(0)
			B := int64(-1)
			for _, p := range uncut {
				length := p.end - p.start
				if sum+length >= target {
					B = p.start + (target - sum)
					break
				}
				sum += length
			}
			fmt.Printf("%d %d %d %d\n", x, A, x, B)
			return
		}
	}

	for y, Hy := range horizV {
		if (Hy ^ X) < Hy {
			target := Hy - (Hy ^ X)
			uncut := horizUncut[y]
			A := uncut[0].start
			sum := int64(0)
			B := int64(-1)
			for _, p := range uncut {
				length := p.end - p.start
				if sum+length >= target {
					B = p.start + (target - sum)
					break
				}
				sum += length
			}
			fmt.Printf("%d %d %d %d\n", A, y, B, y)
			return
		}
	}

	if int64(len(vertV)) < n-1 && (m^X) < m {
		for x := int64(1); x < n; x++ {
			if _, exists := vertV[x]; !exists {
				target := m - (m ^ X)
				fmt.Printf("%d %d %d %d\n", x, 0, x, target)
				return
			}
		}
	}

	if int64(len(horizV)) < m-1 && (n^X) < n {
		for y := int64(1); y < m; y++ {
			if _, exists := horizV[y]; !exists {
				target := n - (n ^ X)
				fmt.Printf("%d %d %d %d\n", 0, y, target, y)
				return
			}
		}
	}
}
```