For problem statement at 1000-1999/1300-1399/1330-1339/1334/problemF.txt this is a correct solution, but verifier at 1000-1999/1300-1399/1330-1339/1334/verifierF.go ends with case 1 failed: runtime error: exit status 2
panic: runtime error: index out of range [4] with length 2

goroutine 1 [running]:
main.main()
	/tmp/build-4220416868/solution.go:92 +0x7b8

input:
1
3
1
1
4
exit status 1 can you fix the verifier? package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) NextInt() int {
	n := len(fs.data)
	for fs.idx < n {
		c := fs.data[fs.idx]
		if (c >= '0' && c <= '9') || c == '-' {
			break
		}
		fs.idx++
	}
	sign := 1
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	val := 0
	for fs.idx < n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		val = val*10 + int(c-'0')
		fs.idx++
	}
	return sign * val
}

type BIT struct {
	n   int
	bit []int64
}

func NewBIT(n int) *BIT {
	return &BIT{n: n, bit: make([]int64, n+2)}
}

func (ft *BIT) Add(i int, delta int64) {
	for i <= ft.n {
		ft.bit[i] += delta
		i += i & -i
	}
}

func (ft *BIT) Sum(i int) int64 {
	var s int64
	for i > 0 {
		s += ft.bit[i]
		i -= i & -i
	}
	return s
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := FastScanner{data: data}

	n := fs.NextInt()
	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = fs.NextInt()
	}

	p := make([]int64, n)
	var total int64
	for i := 0; i < n; i++ {
		x := int64(fs.NextInt())
		p[i] = x
		total += x
	}

	m := fs.NextInt()
	b := make([]int, m+1)
	for i := 1; i <= m; i++ {
		b[i] = fs.NextInt()
	}

	exact := make([]int, n+1)
	for i := 1; i <= m; i++ {
		exact[b[i]] = i
	}

	stage := make([]int, n+1)
	j := 1
	for v := 1; v <= n; v++ {
		for j <= m && b[j] < v {
			j++
		}
		stage[v] = j
	}

	bit := NewBIT(m)
	val := make([]int64, m+1)
	reach := make([]bool, m+1)
	reach[0] = true

	for i := 0; i < n; i++ {
		v := a[i]
		cost := p[i]

		t := stage[v]
		if t <= m && cost > 0 {
			bit.Add(t, cost)
		}

		j := exact[v]
		if j != 0 {
			var prev int64
			if j == 1 {
				prev = 0
			} else {
				if !reach[j-1] {
					continue
				}
				prev = val[j-1] + bit.Sum(j-1)
			}
			cand := prev + cost - bit.Sum(j)
			if !reach[j] || cand > val[j] {
				val[j] = cand
				reach[j] = true
			}
		}
	}

	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	if !reach[m] {
		out.WriteString("NO\n")
	} else {
		keep := val[m] + bit.Sum(m)
		ans := total - keep
		out.WriteString("YES\n")
		out.WriteString(strconv.FormatInt(ans, 10))
		out.WriteByte('\n')
	}
	out.Flush()
}