For problem statement at 1000-1999/1300-1399/1340-1349/1340/problemF.txt this is a correct solution, but verifier at 1000-1999/1300-1399/1340-1349/1340/verifierF.go ends with All tests passed. can you fix the verifier? ```go
package main
import (
"bufio"
"os"
"strconv"
)
const M1 uint64 = 1000000007
const M2 uint64 = 1000000009
const B1 uint64 = 313
const B2 uint64 = 317
var pow1 [100005]uint64
var pow2 [100005]uint64
func initHash() {
pow1[0] = 1
pow2[0] = 1
for i := 1; i <= 100002; i++ {
pow1[i] = (pow1[i-1] * B1) % M1
pow2[i] = (pow2[i-1] * B2) % M2
}
}
type Node struct {
len_O int32
len_C int32
left int32
right int32
hash_O1 uint64
hash_O2 uint64
hash_C1 uint64
hash_C2 uint64
canc1 uint64
canc2 uint64
valid bool
}
const MAX_NODES = 400100
var nodes [MAX_NODES]Node
var pool_cnt int32
type Hash struct {
h1 uint64
h2 uint64
}
func get_prefix_O(idx int32, k int32) Hash {
if k == 0 {
return Hash{0, 0}
}
node := &nodes[idx]
if node.len_O == k {
return Hash{node.hash_O1, node.hash_O2}
}
L_idx := node.left
R_idx := node.right
m := nodes[L_idx].len_O
if nodes[R_idx].len_C < m {
m = nodes[R_idx].len_C
}
if k <= nodes[R_idx].len_O {
return get_prefix_O(R_idx, k)
} else {
X := k - nodes[R_idx].len_O
h1 := get_prefix_O(L_idx, m+X)
h2_h1 := node.canc1
h2_h2 := node.canc2
val1 := (h1.h1 + M1 - (h2_h1*pow1[X])%M1) % M1
val2 := (h1.h2 + M2 - (h2_h2*pow2[X])%M2) % M2
res1 := (nodes[R_idx].hash_O1 + val1*pow1[nodes[R_idx].len_O]) % M1
res2 := (nodes[R_idx].hash_O2 + val2*pow2[nodes[R_idx].len_O]) % M2
return Hash{res1, res2}
}
}
func get_prefix_C(idx int32, k int32) Hash {
if k == 0 {
return Hash{0, 0}
}
node := &nodes[idx]
if node.len_C == k {
return Hash{node.hash_C1, node.hash_C2}
}
L_idx := node.left
R_idx := node.right
m := nodes[L_idx].len_O
if nodes[R_idx].len_C < m {
m = nodes[R_idx].len_C
}
if k <= nodes[L_idx].len_C {
return get_prefix_C(L_idx, k)
} else {
X := k - nodes[L_idx].len_C
h1 := get_prefix_C(R_idx, m+X)
h2_h1 := node.canc1
h2_h2 := node.canc2
val1 := (h1.h1 + M1 - (h2_h1*pow1[X])%M1) % M1
val2 := (h1.h2 + M2 - (h2_h2*pow2[X])%M2) % M2
res1 := (nodes[L_idx].hash_C1 + val1*pow1[nodes[L_idx].len_C]) % M1
res2 := (nodes[L_idx].hash_C2 + val2*pow2[nodes[L_idx].len_C]) % M2
return Hash{res1, res2}
}
}
func merge_nodes(idx int32, left_idx int32, right_idx int32) {
node := &nodes[idx]
L := &nodes[left_idx]
R := &nodes[right_idx]
node.left = left_idx
node.right = right_idx
if !L.valid || !R.valid {
node.valid = false
return
}
m := L.len_O
if R.len_C < m {
m = R.len_C
}
if m > 0 {
hO := get_prefix_O(left_idx, m)
hC := get_prefix_C(right_idx, m)
if hO.h1 != hC.h1 || hO.h2 != hC.h2 {
node.valid = false
return
}
node.canc1 = hO.h1
node.canc2 = hO.h2
} else {
node.canc1 = 0
node.canc2 = 0
}
node.valid = true
node.len_O = L.len_O - m + R.len_O
node.len_C = L.len_C + R.len_C - m
if L.len_O > m {
X := L.len_O - m
val1 := (L.hash_O1 + M1 - (node.canc1*pow1[X])%M1) % M1
val2 := (L.hash_O2 + M2 - (node.canc2*pow2[X])%M2) % M2
node.hash_O1 = (R.hash_O1 + val1*pow1[R.len_O]) % M1
node.hash_O2 = (R.hash_O2 + val2*pow2[R.len_O]) % M2
} else {
node.hash_O1 = R.hash_O1
node.hash_O2 = R.hash_O2
}
if R.len_C > m {
X := R.len_C - m
val1 := (R.hash_C1 + M1 - (node.canc1*pow1[X])%M1) % M1
val2 := (R.hash_C2 + M2 - (node.canc2*pow2[X])%M2) % M2
node.hash_C1 = (L.hash_C1 + val1*pow1[L.len_C]) % M1
node.hash_C2 = (L.hash_C2 + val2*pow2[L.len_C]) % M2
} else {
node.hash_C1 = L.hash_C1
node.hash_C2 = L.hash_C2
}
}
func build(v int32, tl int32, tr int32, s []int) {
if tl == tr {
nodes[v].left = 0
nodes[v].right = 0
nodes[v].valid = true
nodes[v].canc1 = 0
nodes[v].canc2 = 0
val := s[tl]
if val > 0 {
nodes[v].len_O = 1
nodes[v].len_C = 0
nodes[v].hash_O1 = uint64(val)
nodes[v].hash_O2 = uint64(val)
nodes[v].hash_C1 = 0
nodes[v].hash_C2 = 0
} else {
nodes[v].len_O = 0
nodes[v].len_C = 1
nodes[v].hash_O1 = 0
nodes[v].hash_O2 = 0
nodes[v].hash_C1 = uint64(-val)
nodes[v].hash_C2 = uint64(-val)
}
return
}
tm := (tl + tr) / 2
build(v*2, tl, tm, s)
build(v*2+1, tm+1, tr, s)
merge_nodes(v, v*2, v*2+1)
}
func update(v int32, tl int32, tr int32, pos int32, val int) {
if tl == tr {
if val > 0 {
nodes[v].len_O = 1
nodes[v].len_C = 0
nodes[v].hash_O1 = uint64(val)
nodes[v].hash_O2 = uint64(val)
nodes[v].hash_C1 = 0
nodes[v].hash_C2 = 0
} else {
nodes[v].len_O = 0
nodes[v].len_C = 1
nodes[v].hash_O1 = 0
nodes[v].hash_O2 = 0
nodes[v].hash_C1 = uint64(-val)
nodes[v].hash_C2 = uint64(-val)
}
return
}
tm := (tl + tr) / 2
if pos <= tm {
update(v*2, tl, tm, pos, val)
} else {
update(v*2+1, tm+1, tr, pos, val)
}
merge_nodes(v, v*2, v*2+1)
}
func query(v int32, tl int32, tr int32, l int32, r int32) int32 {
if l > tr || r < tl {
return 0
}
if l <= tl && tr <= r {
return v
}
tm := (tl + tr) / 2
left_res := query(v*2, tl, tm, l, r)
right_res := query(v*2+1, tm+1, tr, l, r)
if left_res == 0 {
return right_res
}
if right_res == 0 {
return left_res
}
pool_cnt++
idx := pool_cnt
merge_nodes(idx, left_res, right_res)
return idx
}
func main() {
initHash()
scanner := bufio.NewScanner(os.Stdin)
scanner.Split(bufio.ScanWords)
buf := make([]byte, 1024*1024)
scanner.Buffer(buf, 10*1024*1024)
scanInt := func() int {
scanner.Scan()
res, _ := strconv.Atoi(scanner.Text())
return res
}
if !scanner.Scan() {
return
}
n, _ := strconv.Atoi(scanner.Text())
scanInt()
s := make([]int, n+1)
for i := 1; i <= n; i++ {
s[i] = scanInt()
}
build(1, 1, int32(n), s)
q := scanInt()
writer := bufio.NewWriter(os.Stdout)
defer writer.Flush()
for i := 0; i < q; i++ {
typ := scanInt()
if typ == 1 {
pos := scanInt()
val := scanInt()
update(1, 1, int32(n), int32(pos), val)
} else {
l := scanInt()
r := scanInt()
pool_cnt = 400005
res := query(1, 1, int32(n), int32(l), int32(r))
if nodes[res].valid && nodes[res].len_O == 0 && nodes[res].len_C == 0 {
writer.WriteString("Yes\n")
} else {
writer.WriteString("No\n")
}
}
}
}
```