For problem statement at 1000-1999/1200-1299/1250-1259/1252/problemG.txt this is a correct solution, but verifier at 1000-1999/1200-1299/1250-1259/1252/verifierG.go ends with all tests passed can you fix the verifier? package main

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

var (
	tree []int
	lazy []int
)

func build(node, l, r int, P []int) {
	if l == r {
		tree[node] = P[l]
		return
	}
	mid := l + (r-l)/2
	build(2*node, l, mid, P)
	build(2*node+1, mid+1, r, P)
	if tree[2*node] < tree[2*node+1] {
		tree[node] = tree[2*node]
	} else {
		tree[node] = tree[2*node+1]
	}
}

func push(node int) {
	if lazy[node] != 0 {
		tree[2*node] += lazy[node]
		lazy[2*node] += lazy[node]
		tree[2*node+1] += lazy[node]
		lazy[2*node+1] += lazy[node]
		lazy[node] = 0
	}
}

func update(node, l, r, ql, qr, val int) {
	if ql > r || qr < l {
		return
	}
	if ql <= l && r <= qr {
		tree[node] += val
		lazy[node] += val
		return
	}
	push(node)
	mid := l + (r-l)/2
	update(2*node, l, mid, ql, qr, val)
	update(2*node+1, mid+1, r, ql, qr, val)
	if tree[2*node] < tree[2*node+1] {
		tree[node] = tree[2*node]
	} else {
		tree[node] = tree[2*node+1]
	}
}

type FastScanner struct {
	buf  []byte
	pos  int
	tail int
	in   io.Reader
}

func NewFastScanner(r io.Reader) *FastScanner {
	return &FastScanner{
		buf: make([]byte, 1<<16),
		in:  r,
	}
}

func (s *FastScanner) NextInt() int {
	for {
		if s.pos >= s.tail {
			n, _ := s.in.Read(s.buf)
			if n == 0 {
				return 0
			}
			s.pos = 0
			s.tail = n
		}
		if s.buf[s.pos] > 32 {
			break
		}
		s.pos++
	}
	res := 0
	for {
		if s.pos >= s.tail {
			n, _ := s.in.Read(s.buf)
			if n == 0 {
				break
			}
			s.pos = 0
			s.tail = n
		}
		if s.buf[s.pos] <= 32 {
			break
		}
		res = res*10 + int(s.buf[s.pos]-'0')
		s.pos++
	}
	return res
}

func main() {
	in := NewFastScanner(os.Stdin)

	n := in.NextInt()
	m := in.NextInt()
	q := in.NextInt()

	a1 := in.NextInt()
	w := 0
	for i := 1; i < n; i++ {
		ai := in.NextInt()
		if ai < a1 {
			w++
		}
	}

	B := make([][]int, m+1)
	R := make([]int, m+1)
	P := make([]int, m+1)
	S := 0

	for i := 1; i <= m; i++ {
		R[i] = in.NextInt()
		B[i] = make([]int, R[i]+1)
		k := 0
		for j := 1; j <= R[i]; j++ {
			B[i][j] = in.NextInt()
			if B[i][j] < a1 {
				k++
			}
		}
		delta := k - R[i]
		P[i] = S - R[i]
		S += delta
	}

	tree = make([]int, 4*m+1)
	lazy = make([]int, 4*m+1)
	if m > 0 {
		build(1, 1, m, P)
	}

	for i := 0; i < q; i++ {
		X := in.NextInt()
		Y := in.NextInt()
		Z := in.NextInt()

		old := B[X][Y]
		B[X][Y] = Z

		v := 0
		if old < a1 && Z > a1 {
			v = -1
		} else if old > a1 && Z < a1 {
			v = 1
		}

		if v != 0 && X < m {
			update(1, 1, m, X+1, m, v)
		}

		if m > 0 {
			if w+tree[1] >= 0 {
				fmt.Println(1)
			} else {
				fmt.Println(0)
			}
		} else {
			fmt.Println(1)
		}
	}
}