For problem statement at 1000-1999/1300-1399/1380-1389/1386/problemB.txt this is a correct solution, but verifier at 1000-1999/1300-1399/1380-1389/1386/verifierB.go ends with All tests passed can you fix the verifier? ```go
package main
import (
"bufio"
"fmt"
"math/bits"
"os"
)
type Ray struct {
x, y int64
}
var (
count0 int
rayCounts = make(map[Ray]int)
oppositePairs int
badPairs int
tree = &Treap{}
bottles = make(map[int]Ray)
bottleOrigin = make(map[int]bool)
)
func gcd(a, b int64) int64 {
if a < 0 {
a = -a
}
if b < 0 {
b = -b
}
for b != 0 {
a, b = b, a%b
}
return a
}
func normalize(x, y int64) Ray {
g := gcd(x, y)
return Ray{x / g, y / g}
}
func opposite(r Ray) Ray {
return Ray{-r.x, -r.y}
}
func mul128(a, b int64) (hi int64, lo uint64) {
sign := int64(1)
if a < 0 {
a = -a
sign = -sign
}
if b < 0 {
b = -b
sign = -sign
}
hiU, lo := bits.Mul64(uint64(a), uint64(b))
if sign < 0 {
lo = ^lo + 1
hiU = ^hiU
if lo == 0 {
hiU++
}
}
return int64(hiU), lo
}
func cmp128(hi1 int64, lo1 uint64, hi2 int64, lo2 uint64) int {
if hi1 != hi2 {
if hi1 < hi2 {
return -1
}
return 1
}
if lo1 != lo2 {
if lo1 < lo2 {
return -1
}
return 1
}
return 0
}
func crossSign(a, b Ray) int {
hi1, lo1 := mul128(a.x, b.y)
hi2, lo2 := mul128(a.y, b.x)
return cmp128(hi1, lo1, hi2, lo2)
}
func half(a Ray) int {
if a.y > 0 || (a.y == 0 && a.x > 0) {
return 1
}
return 0
}
func cmpRay(a, b Ray) int {
ha := half(a)
hb := half(b)
if ha != hb {
if ha > hb {
return -1
}
return 1
}
c := crossSign(a, b)
if c > 0 {
return -1
}
if c < 0 {
return 1
}
return 0
}
type Node struct {
key Ray
priority uint32
left *Node
right *Node
}
type Treap struct {
root *Node
size int
}
var seed uint32 = 12345
func fastRand() uint32 {
seed ^= seed << 13
seed ^= seed >> 17
seed ^= seed << 5
return seed
}
func (t *Treap) Size() int {
return t.size
}
func rightRotate(y *Node) *Node {
x := y.left
y.left = x.right
x.right = y
return x
}
func leftRotate(x *Node) *Node {
y := x.right
x.right = y.left
y.left = x
return y
}
func insertNode(root *Node, key Ray) *Node {
if root == nil {
return &Node{key: key, priority: fastRand()}
}
cmp := cmpRay(key, root.key)
if cmp < 0 {
root.left = insertNode(root.left, key)
if root.left.priority > root.priority {
root = rightRotate(root)
}
} else if cmp > 0 {
root.right = insertNode(root.right, key)
if root.right.priority > root.priority {
root = leftRotate(root)
}
}
return root
}
func (t *Treap) Insert(key Ray) {
t.root = insertNode(t.root, key)
t.size++
}
func deleteNode(root *Node, key Ray) *Node {
if root == nil {
return nil
}
cmp := cmpRay(key, root.key)
if cmp < 0 {
root.left = deleteNode(root.left, key)
} else if cmp > 0 {
root.right = deleteNode(root.right, key)
} else {
if root.left == nil {
return root.right
} else if root.right == nil {
return root.left
}
if root.left.priority > root.right.priority {
root = rightRotate(root)
root.right = deleteNode(root.right, key)
} else {
root = leftRotate(root)
root.left = deleteNode(root.left, key)
}
}
return root
}
func (t *Treap) Delete(key Ray) {
t.root = deleteNode(t.root, key)
t.size--
}
func (t *Treap) Min() Ray {
curr := t.root
for curr.left != nil {
curr = curr.left
}
return curr.key
}
func (t *Treap) Max() Ray {
curr := t.root
for curr.right != nil {
curr = curr.right
}
return curr.key
}
func (t *Treap) Pred(key Ray) Ray {
var best *Node
curr := t.root
for curr != nil {
if cmpRay(curr.key, key) < 0 {
best = curr
curr = curr.right
} else {
curr = curr.left
}
}
if best == nil {
return t.Max()
}
return best.key
}
func (t *Treap) Succ(key Ray) Ray {
var best *Node
curr := t.root
for curr != nil {
if cmpRay(curr.key, key) > 0 {
best = curr
curr = curr.left
} else {
curr = curr.right
}
}
if best == nil {
return t.Min()
}
return best.key
}
func insertRay(r Ray) {
if tree.Size() == 0 {
tree.Insert(r)
return
}
p := tree.Pred(r)
s := tree.Succ(r)
if crossSign(p, s) < 0 {
badPairs--
}
if crossSign(p, r) < 0 {
badPairs++
}
if crossSign(r, s) < 0 {
badPairs++
}
tree.Insert(r)
}
func removeRay(r Ray) {
if tree.Size() == 1 {
tree.Delete(r)
return
}
p := tree.Pred(r)
s := tree.Succ(r)
if crossSign(p, r) < 0 {
badPairs--
}
if crossSign(r, s) < 0 {
badPairs--
}
if crossSign(p, s) < 0 {
badPairs++
}
tree.Delete(r)
}
func nextInt64(r *bufio.Reader) int64 {
var n int64
var c byte
var err error
for {
c, err = r.ReadByte()
if err != nil || (c >= '0' && c <= '9') || c == '-' {
break
}
}
sign := int64(1)
if c == '-' {
sign = -1
c, _ = r.ReadByte()
}
for err == nil && c >= '0' && c <= '9' {
n = n*10 + int64(c-'0')
c, err = r.ReadByte()
}
return n * sign
}
func nextChar(r *bufio.Reader) byte {
var c byte
var err error
for {
c, err = r.ReadByte()
if err != nil || (c >= 'A' && c <= 'Z') {
break
}
}
return c
}
func main() {
reader := bufio.NewReader(os.Stdin)
writer := bufio.NewWriter(os.Stdout)
defer writer.Flush()
Sf := nextInt64(reader)
Pf := nextInt64(reader)
Gf := nextInt64(reader)
N := int(nextInt64(reader))
bottleID := 1
for i := 0; i < N; i++ {
op := nextChar(reader)
if op == 'A' {
Si := nextInt64(reader)
Pi := nextInt64(reader)
Gi := nextInt64(reader)
X := Si*(Sf+Pf+Gf) - Sf*(Si+Pi+Gi)
Y := Pi*(Sf+Pf+Gf) - Pf*(Si+Pi+Gi)
if X == 0 && Y == 0 {
count0++
bottleOrigin[bottleID] = true
} else {
r := normalize(X, Y)
bottles[bottleID] = r
if rayCounts[r] == 0 {
if rayCounts[opposite(r)] > 0 {
oppositePairs++
}
insertRay(r)
}
rayCounts[r]++
}
bottleID++
} else if op == 'R' {
r_i := int(nextInt64(reader))
if bottleOrigin[r_i] {
count0--
delete(bottleOrigin, r_i)
} else {
r := bottles[r_i]
rayCounts[r]--
if rayCounts[r] == 0 {
if rayCounts[opposite(r)] > 0 {
oppositePairs--
}
removeRay(r)
}
delete(bottles, r_i)
}
}
if count0 > 0 {
fmt.Fprintln(writer, 1)
} else if oppositePairs > 0 {
fmt.Fprintln(writer, 2)
} else if tree.Size() >= 3 && badPairs == 0 {
fmt.Fprintln(writer, 3)
} else {
fmt.Fprintln(writer, 0)
}
}
}
```