For problem statement at 2000-2999/2100-2199/2110-2119/2119/problemE.txt this is a correct solution, but verifier at 2000-2999/2100-2199/2110-2119/2119/verifierE.go ends with candidate runtime error: runtime error: exit status 2
panic: runtime error: index out of range [3] with length 3

goroutine 1 [running]:
main.main()
	/tmp/build-1912842976/solution.go:37 +0xbcc

exit status 1 can you fix the verifier? package main

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

const INF int64 = 2e18

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

	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		var n int
		fmt.Fscan(reader, &n)
		a := make([]int64, n-1)
		for i := 0; i < n-1; i++ {
			fmt.Fscan(reader, &a[i])
		}
		b := make([]int64, n)
		var sumB int64 = 0
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &b[i])
			sumB += b[i]
		}

		possible := true
		for i := 1; i < n-1; i++ {
			if (a[i-1] & a[i+1] & ^a[i]) != 0 {
				possible = false
				break
			}
		}
		if !possible {
			fmt.Fprintln(writer, -1)
			continue
		}

		var prevVals []int64
		var prevCosts []int64

		for i := 0; i < n; i++ {
			var M int64 = 0
			if i > 0 {
				M |= a[i-1]
			}
			if i < n-1 {
				M |= a[i]
			}

			cands := make([]int64, 0, 40)
			seen := make(map[int64]bool)

			cand := b[i] | M
			if cand >= b[i] {
				seen[cand] = true
				cands = append(cands, cand)
			}

			for L := 0; L <= 35; L++ {
				if (b[i] & (int64(1) << L)) == 0 {
					c := (b[i] & ^((int64(1) << (L + 1)) - 1)) | (int64(1) << L) | M
					if c >= b[i] && !seen[c] {
						seen[c] = true
						cands = append(cands, c)
					}
				}
			}

			var currVals []int64
			var currCosts []int64

			for _, c := range cands {
				if i == 0 {
					currVals = append(currVals, c)
					currCosts = append(currCosts, c)
				} else {
					minCost := INF
					target := a[i-1]
					for j, pVal := range prevVals {
						if (pVal & c) == target {
							if prevCosts[j] < minCost {
								minCost = prevCosts[j]
							}
						}
					}
					if minCost != INF {
						currVals = append(currVals, c)
						currCosts = append(currCosts, minCost+c)
					}
				}
			}
			prevVals = currVals
			prevCosts = currCosts
		}

		var ans int64 = INF
		for _, cost := range prevCosts {
			if cost < ans {
				ans = cost
			}
		}

		if ans == INF {
			fmt.Fprintln(writer, -1)
		} else {
			fmt.Fprintln(writer, ans-sumB)
		}
	}
}