For problem statement at 0-999/800-899/850-859/856/problemE.txt this is a correct solution, but verifier at 0-999/800-899/850-859/856/verifierE.go ends with case 6 failed: expected "YES\nNO" got "YES\nYES"
input:
1 10
1 6 9
1 10 6
2 1
1 4 9
1 5 6
1 2 9
3 3 5
2 3
3 2 4
2 4
exit status 1 can you fix the verifier? ```go
package main

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

func readInt(reader *bufio.Reader) int {
	var n int
	var sign int = 1
	for {
		b, err := reader.ReadByte()
		if err != nil {
			return 0
		}
		if b == '-' {
			sign = -1
			continue
		}
		if b >= '0' && b <= '9' {
			n = int(b - '0')
			break
		}
	}
	for {
		b, err := reader.ReadByte()
		if err != nil || b < '0' || b > '9' {
			return n * sign
		}
		n = n*10 + int(b-'0')
	}
}

type Event struct {
	typ int
	a, b int
	id   int
}

type Satellite struct {
	id   int
	x, y int64
}

type Node struct {
	top [3]int
	cnt int
}

var R int64
var sat []Satellite
var sortedSats []int
var leafIdx []int
var tree []Node

func uGreater(id1, id2 int) bool {
	p1 := (sat[id1].x + R) * sat[id2].y
	p2 := (sat[id2].x + R) * sat[id1].y
	return p1 > p2
}

func vGreater(id1, id2 int) bool {
	p1 := (sat[id1].x - R) * sat[id2].y
	p2 := (sat[id2].x - R) * sat[id1].y
	if p1 == p2 {
		return id1 > id2
	}
	return p1 > p2
}

func vGreaterEq(id1, id2 int) bool {
	p1 := (sat[id1].x - R) * sat[id2].y
	p2 := (sat[id2].x - R) * sat[id1].y
	return p1 >= p2
}

func validGeo(u_ref, v_ref int) bool {
	xu, yu := sat[u_ref].x, sat[u_ref].y
	xv, yv := sat[v_ref].x, sat[v_ref].y
	return (xu+R)*(xv-R) >= -yu*yv
}

func merge(a, b Node) Node {
	var res Node
	i, j := 0, 0
	for i < a.cnt && j < b.cnt && res.cnt < 3 {
		if vGreater(a.top[i], b.top[j]) {
			res.top[res.cnt] = a.top[i]
			res.cnt++
			i++
		} else {
			res.top[res.cnt] = b.top[j]
			res.cnt++
			j++
		}
	}
	for i < a.cnt && res.cnt < 3 {
		res.top[res.cnt] = a.top[i]
		res.cnt++
		i++
	}
	for j < b.cnt && res.cnt < 3 {
		res.top[res.cnt] = b.top[j]
		res.cnt++
		j++
	}
	return res
}

func update(node, l, r, idx, id, op int) {
	if l == r {
		if op == 1 {
			tree[node].top[0] = id
			tree[node].cnt = 1
		} else {
			tree[node].cnt = 0
		}
		return
	}
	mid := (l + r) / 2
	if idx <= mid {
		update(2*node, l, mid, idx, id, op)
	} else {
		update(2*node+1, mid+1, r, idx, id, op)
	}
	tree[node] = merge(tree[2*node], tree[2*node+1])
}

func queryTree(node, l, r, ql, qr int) Node {
	if ql <= l && r <= qr {
		return tree[node]
	}
	mid := (l + r) / 2
	if qr <= mid {
		return queryTree(2*node, l, mid, ql, qr)
	}
	if ql > mid {
		return queryTree(2*node+1, mid+1, r, ql, qr)
	}
	return merge(
		queryTree(2*node, l, mid, ql, qr),
		queryTree(2*node+1, mid+1, r, ql, qr),
	)
}

func findRightmostU(u_ref, K int) int {
	l, r_idx := 0, K-1
	ans := -1
	for l <= r_idx {
		mid := (l + r_idx) / 2
		id := sortedSats[mid]
		p1 := (sat[id].x + R) * sat[u_ref].y
		p2 := (sat[u_ref].x + R) * sat[id].y
		if p1 <= p2 {
			ans = mid
			l = mid + 1
		} else {
			r_idx = mid - 1
		}
	}
	return ans
}

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 64*1024)
	writer := bufio.NewWriterSize(os.Stdout, 64*1024)
	defer writer.Flush()

	r_planet := readInt(reader)
	n := readInt(reader)
	R = int64(r_planet)

	events := make([]Event, n)
	K := 0
	curId := 0
	for i := 0; i < n; i++ {
		typ := readInt(reader)
		events[i].typ = typ
		if typ == 1 {
			events[i].a = readInt(reader)
			events[i].b = readInt(reader)
			curId++
			events[i].id = curId
			K++
		} else if typ == 2 {
			events[i].a = readInt(reader)
		} else {
			events[i].a = readInt(reader)
			events[i].b = readInt(reader)
		}
	}

	if K == 0 {
		return
	}

	sat = make([]Satellite, K+1)
	for i := 0; i < n; i++ {
		if events[i].typ == 1 {
			id := events[i].id
			sat[id] = Satellite{id: id, x: int64(events[i].a), y: int64(events[i].b)}
		}
	}

	sortedSats = make([]int, K)
	for i := 0; i < K; i++ {
		sortedSats[i] = i + 1
	}
	sort.Slice(sortedSats, func(i, j int) bool {
		id1, id2 := sortedSats[i], sortedSats[j]
		p1 := (sat[id1].x + R) * sat[id2].y
		p2 := (sat[id2].x + R) * sat[id1].y
		if p1 == p2 {
			return id1 < id2
		}
		return p1 < p2
	})

	leafIdx = make([]int, K+1)
	for i, id := range sortedSats {
		leafIdx[id] = i
	}

	tree = make([]Node, 4*K)

	for i := 0; i < n; i++ {
		ev := events[i]
		if ev.typ == 1 {
			id := ev.id
			idx := leafIdx[id]
			update(1, 0, K-1, idx, id, 1)
		} else if ev.typ == 2 {
			id := ev.a
			idx := leafIdx[id]
			update(1, 0, K-1, idx, id, 0)
		} else if ev.typ == 3 {
			i_id, j_id := ev.a, ev.b

			u_ref := i_id
			if uGreater(j_id, i_id) {
				u_ref = j_id
			}

			v_ref := i_id
			if vGreater(i_id, j_id) {
				v_ref = j_id
			}

			if !validGeo(u_ref, v_ref) {
				writer.WriteString("NO\n")
				continue
			}

			R_idx := findRightmostU(u_ref, K)
			if R_idx == -1 {
				writer.WriteString("NO\n")
				continue
			}

			res := queryTree(1, 0, K-1, 0, R_idx)

			interference := false
			for idx := 0; idx < res.cnt; idx++ {
				k := res.top[idx]
				if k == i_id || k == j_id {
					continue
				}
				if vGreaterEq(k, v_ref) {
					interference = true
					break
				}
			}

			if interference {
				writer.WriteString("NO\n")
			} else {
				writer.WriteString("YES\n")
			}
		}
	}
}
```