For problem statement at 2000-2999/2100-2199/2100-2109/2107/problemF1.txt this is a correct solution, but verifier at 2000-2999/2100-2199/2100-2109/2107/verifierF1.go ends with wrong answer on iteration 1 case 1
input case n: 5 a: [634859125 6947 913004 1 1]
reference: 635779078
candidate: 11

exit status 1 can you fix the verifier? ```go
package main

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

func abs(x int) int {
	if x < 0 {
		return -x
	}
	return x
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

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
	}

	const INF int = 1000000000000000000

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

		dp := make([][]int, 2)
		for i := range dp {
			dp[i] = make([]int, 2*n+3)
			for j := range dp[i] {
				dp[i][j] = INF
			}
		}

		offset := n + 1
		dp[0][offset] = 0

		for i := 1; i <= n; i++ {
			curr := i % 2
			prev := (i - 1) % 2
			for j := range dp[curr] {
				dp[curr][j] = INF
			}

			for j := -n; j <= n; j++ {
				idx := j + offset
				
				val1 := INF
				if idx+1 < len(dp[prev]) {
					val1 = dp[prev][idx+1]
				}

				val2 := INF
				if idx-1 >= 0 && dp[curr][idx-1] != INF {
					val2 = dp[curr][idx-1] - abs(j-1) + a[i]
				}

				best := min(val1, val2)
				if best != INF {
					dp[curr][idx] = best + abs(j)
				}
			}
		}

		fmt.Fprintln(writer, dp[n%2][offset])
	}
}
```