For problem statement at 1000-1999/1600-1699/1600-1609/1609/problemG.txt this is a correct solution, but verifier at 1000-1999/1600-1699/1600-1609/1609/verifierG.go ends with case 1 failed: expected 723
730
760
800
802
810 got 9223372036854776814
9223372036854776763
9223372036854776785
9223372036854776805
9223372036854776807
9223372036854776811
input:
3 5 6
96 47 54
65 29 18 23 85
2 3 3
1 1 3
1 3 2
1 2 5
1 1 1
1 2 1
exit status 1 can you fix the verifier? ```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

var (
	bit1 []uint64
	bit2 []uint64
	bit3 []uint64
	m    int
)

func add(idx int, d uint64) {
	if idx > m {
		return
	}
	v1 := d
	v2 := uint64(idx) * d
	v3 := uint64(idx) * uint64(idx) * d
	for i := idx; i <= m; i += i & -i {
		bit1[i] += v1
		bit2[i] += v2
		bit3[i] += v3
	}
}

func querySumB(Y int, b1 uint64) uint64 {
	if Y == 0 {
		return 0
	}
	y := uint64(Y)
	var sum1, sum2, sum3 uint64
	for i := Y; i > 0; i -= i & -i {
		sum1 += bit1[i]
		sum2 += bit2[i]
		sum3 += bit3[i]
	}
	term := (y+1)*(y+2)*sum1 + sum3 - (2*y+3)*sum2
	return y*b1 + term/2
}

func findC(A uint64) int {
	sum := uint64(0)
	pos := 0
	for i := 17; i >= 0; i-- {
		nextPos := pos + (1 << i)
		if nextPos <= m && sum+bit1[nextPos] < A {
			sum += bit1[nextPos]
			pos = nextPos
		}
	}
	if pos == 0 {
		return 1
	}
	return pos
}

func readUint64(r *bufio.Reader) uint64 {
	var n uint64
	var c byte
	var err error
	for {
		c, err = r.ReadByte()
		if err != nil || c > 32 {
			break
		}
	}
	if err != nil {
		return 0
	}
	for c >= '0' && c <= '9' {
		n = n*10 + uint64(c-'0')
		c, err = r.ReadByte()
		if err != nil {
			break
		}
	}
	return n
}

func readInt(r *bufio.Reader) int {
	return int(readUint64(r))
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	n := readInt(reader)
	m = readInt(reader)
	q := readInt(reader)

	a := make([]uint64, n)
	for i := 0; i < n; i++ {
		a[i] = readUint64(reader)
	}

	b := make([]uint64, m)
	for i := 0; i < m; i++ {
		b[i] = readUint64(reader)
	}

	bit1 = make([]uint64, m+1)
	bit2 = make([]uint64, m+1)
	bit3 = make([]uint64, m+1)

	b1 := b[0]
	B := make([]uint64, m+1)
	for i := 2; i <= m; i++ {
		B[i] = b[i-1] - b[i-2]
	}
	for i := 2; i <= m; i++ {
		D_i := B[i] - B[i-1]
		add(i, D_i)
	}

	for i := 0; i < q; i++ {
		typ := readInt(reader)
		k := readInt(reader)
		d := readUint64(reader)

		if typ == 1 {
			for j := 0; j < k; j++ {
				idx := n - k + j
				a[idx] += uint64(j+1) * d
			}
		} else {
			if k == m {
				b1 += d
				add(2, d)
			} else {
				idx := m - k + 1
				add(idx, d)
			}
		}

		totalCost := uint64(0)
		c_prev := 1

		for x := 1; x <= n; x++ {
			c_x := m
			if x < n {
				A_x_plus_1 := a[x] - a[x-1]
				c_x = findC(A_x_plus_1)
			}

			count := uint64(c_x - c_prev + 1)
			totalCost += a[x-1] * count

			sumB_c_x := querySumB(c_x, b1)
			sumB_prev := querySumB(c_prev-1, b1)

			totalCost += sumB_c_x - sumB_prev

			c_prev = c_x
		}

		fmt.Fprintln(writer, totalCost)
	}
}
```