For problem statement at 1000-1999/1700-1799/1770-1779/1774/problemF2.txt this is a correct solution, but verifier at 1000-1999/1700-1799/1770-1779/1774/verifierF2.go ends with All 51 tests passed. can you fix the verifier? ```go
package main

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

const MOD = 998244353
const INF = 1000000001

func readInt(reader *bufio.Reader) int {
	var n int
	var c byte
	for {
		c, _ = reader.ReadByte()
		if c >= '0' && c <= '9' {
			break
		}
	}
	for {
		n = n*10 + int(c-'0')
		c, _ = reader.ReadByte()
		if c < '0' || c > '9' {
			break
		}
	}
	return n
}

type Op struct {
	typ int
	val int
}

type WItem struct {
	idx int
	val int64
}

func main() {
	reader := bufio.NewReaderSize(os.Stdin, 65536)
	n := readInt(reader)

	ops := make([]Op, n+1)
	for i := 1; i <= n; i++ {
		ops[i].typ = readInt(reader)
		if ops[i].typ != 3 {
			ops[i].val = readInt(reader)
		}
	}

	D := make([]int64, n+1)
	D[0] = 0
	for i := 1; i <= n; i++ {
		if ops[i].typ == 1 {
			D[i] = D[i-1]
		} else if ops[i].typ == 2 {
			D[i] = D[i-1] + int64(ops[i].val)
			if D[i] > INF {
				D[i] = INF
			}
		} else {
			D[i] = 2 * D[i-1]
			if D[i] > INF {
				D[i] = INF
			}
		}
	}

	var W_global []WItem
	for i := 1; i <= n; i++ {
		if ops[i].typ == 3 && D[i-1] > 0 && D[i-1] <= 1000000000 {
			W_global = append(W_global, WItem{idx: i, val: D[i-1]})
		}
	}

	m := len(W_global)
	S := make([]int64, m+1)
	for i := 1; i <= m; i++ {
		S[i] = S[i-1] + W_global[i-1].val
	}

	power2 := make([]int, n+1)
	power2[0] = 1
	for i := 1; i <= n; i++ {
		power2[i] = (power2[i-1] * 2) % MOD
	}

	ans := 0
	var fixedDamage int64 = 0
	Z := 0
	ptr := m

	for i := n; i >= 1; i-- {
		if ops[i].typ == 2 {
			fixedDamage += int64(ops[i].val)
			if fixedDamage > INF {
				fixedDamage = INF
			}
		} else if ops[i].typ == 3 {
			if D[i-1] == 0 {
				Z++
			}
			if ptr > 0 && W_global[ptr-1].idx == i {
				ptr--
			}
		} else if ops[i].typ == 1 {
			target := int64(ops[i].val) - fixedDamage
			if target <= 0 {
				continue
			}

			var count int64 = 0
			currTarget := target

			for j := m - 1; j >= ptr; j-- {
				sumRemInc := S[j+1] - S[ptr]
				if currTarget > sumRemInc {
					count = (count + int64(power2[j-ptr+1])) % MOD
					currTarget = 0
					break
				}
				val := W_global[j].val
				if currTarget <= val {
					continue
				} else {
					count = (count + int64(power2[j-ptr])) % MOD
					currTarget -= val
				}
			}
			if currTarget > 0 {
				count = (count + 1) % MOD
			}

			term := (count * int64(power2[Z])) % MOD
			ans = (ans + int(term)) % MOD
		}
	}

	fmt.Println(ans)
}
```