For problem statement at 1000-1999/1400-1499/1450-1459/1458/problemE.txt this is a correct solution, but verifier at 1000-1999/1400-1499/1450-1459/1458/verifierE.go ends with all tests passed can you fix the verifier? package main

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

type Point struct {
	x, y int
}

const MAX_VAL = 2000000005

type Node struct {
	count int
	left  int32
	right int32
	zero  bool
}

var tree []Node

func pushDown(u int32, L, R int) {
	mid := L + (R - L) / 2
	if tree[u].left == 0 {
		tree = append(tree, Node{count: mid - L + 1})
		tree[u].left = int32(len(tree) - 1)
	}
	if tree[u].right == 0 {
		tree = append(tree, Node{count: R - mid})
		tree[u].right = int32(len(tree) - 1)
	}
	if tree[u].zero {
		l := tree[u].left
		r := tree[u].right
		tree[l].count = 0
		tree[l].zero = true
		tree[r].count = 0
		tree[r].zero = true
		tree[u].zero = false
	}
}

func removeFirstK(u int32, k int, L, R int) int {
	if tree[u].count == 0 || k == 0 {
		return k
	}
	if tree[u].count <= k {
		removed := tree[u].count
		tree[u].count = 0
		tree[u].zero = true
		return k - removed
	}
	if L == R {
		tree[u].count -= k
		if tree[u].count == 0 {
			tree[u].zero = true
		}
		return 0
	}
	pushDown(u, L, R)
	mid := L + (R - L) / 2
	k = removeFirstK(tree[u].left, k, L, mid)
	if k > 0 {
		k = removeFirstK(tree[u].right, k, mid+1, R)
	}
	tree[u].count = tree[tree[u].left].count + tree[tree[u].right].count
	return k
}

func removeElement(u int32, y int, L, R int) {
	if tree[u].count == 0 {
		return
	}
	if L == R {
		tree[u].count = 0
		tree[u].zero = true
		return
	}
	pushDown(u, L, R)
	mid := L + (R - L) / 2
	if y <= mid {
		removeElement(tree[u].left, y, L, mid)
	} else {
		removeElement(tree[u].right, y, mid+1, R)
	}
	tree[u].count = tree[tree[u].left].count + tree[tree[u].right].count
}

func getMin(u int32, L, R int) int {
	if tree[u].count == 0 {
		return -1
	}
	if L == R {
		return L
	}
	pushDown(u, L, R)
	mid := L + (R - L) / 2
	if tree[tree[u].left].count > 0 {
		return getMin(tree[u].left, L, mid)
	}
	return getMin(tree[u].right, mid+1, R)
}

var buf []byte
var bufIdx int

func nextInt() int {
	for bufIdx < len(buf) && buf[bufIdx] <= 32 {
		bufIdx++
	}
	if bufIdx >= len(buf) {
		return 0
	}
	res := 0
	for bufIdx < len(buf) && buf[bufIdx] > 32 {
		res = res*10 + int(buf[bufIdx]-'0')
		bufIdx++
	}
	return res
}

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

	n := nextInt()
	m := nextInt()

	if n == 0 && m == 0 {
		return
	}

	shortcutsMap := make(map[Point]bool, n)
	Sx := make(map[int][]int)
	interesting := make([]int, 0, n+m)

	for i := 0; i < n; i++ {
		x := nextInt()
		y := nextInt()
		shortcutsMap[Point{x, y}] = true
		Sx[x] = append(Sx[x], y)
		interesting = append(interesting, x)
	}

	type Query struct {
		x, y int
	}
	queries := make([]Query, m)
	for i := 0; i < m; i++ {
		queries[i].x = nextInt()
		queries[i].y = nextInt()
		interesting = append(interesting, queries[i].x)
	}

	sort.Ints(interesting)
	uniqueInteresting := make([]int, 0, len(interesting))
	for i, x := range interesting {
		if i == 0 || x != interesting[i-1] {
			uniqueInteresting = append(uniqueInteresting, x)
		}
	}

	tree = make([]Node, 1, 8000000)
	tree = append(tree, Node{count: MAX_VAL + 1})

	Y := make(map[int]int, len(uniqueInteresting))
	current_x := 0

	for _, x := range uniqueInteresting {
		gap := x - current_x
		if gap > 0 {
			removeFirstK(1, gap, 0, MAX_VAL)
		}
		current_x = x

		y_star := getMin(1, 0, MAX_VAL)

		listS := Sx[x]
		m_val := MAX_VAL + 10
		for _, y := range listS {
			if y < m_val {
				m_val = y
			}
		}

		if y_star < m_val {
			Y[x] = y_star
			removeElement(1, y_star, 0, MAX_VAL)
		} else {
			Y[x] = -1
		}

		for _, y := range listS {
			if y <= MAX_VAL {
				removeElement(1, y, 0, MAX_VAL)
			}
		}

		current_x = x + 1
	}

	writer := bufio.NewWriterSize(os.Stdout, 1<<20)
	for _, q := range queries {
		if shortcutsMap[Point{q.x, q.y}] {
			writer.WriteString("LOSE\n")
		} else if Y[q.x] == q.y {
			writer.WriteString("LOSE\n")
		} else {
			writer.WriteString("WIN\n")
		}
	}
	writer.Flush()
}