```go
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	var n int
	if _, err := fmt.Fscan(reader, &n); err != nil {
		return
	}

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

	const Words = 3150
	var B [Words]uint64
	B[0] = 2

	maxW := 0

	for i := 1; i <= n; i++ {
		a_i := a[i]
		if a_i == 0 {
			continue
		}

		word_i := i / 64
		if word_i > maxW {
			continue
		}

		bit_i := i % 64
		shiftW := a_i / 64
		shiftB := a_i % 64
		mask := ^uint64(0) << bit_i

		endW := word_i + shiftW
		if endW >= Words {
			continue
		}

		startW := maxW + shiftW + 1
		if startW >= Words {
			startW = Words - 1
		}

		for w := startW; w > endW; w-- {
			srcW := w - shiftW
			val1 := B[srcW]

			var val2 uint64
			if shiftB > 0 {
				if srcW-1 > word_i {
					val2 = B[srcW-1]
				} else {
					val2 = B[srcW-1] & mask
				}
			}

			res := val1 << shiftB
			if shiftB > 0 {
				res |= val2 >> (64 - shiftB)
			}

			B[w] |= res
		}

		val1 := B[word_i] & mask
		B[endW] |= val1 << shiftB

		if startW > maxW {
			maxW = startW
		}
		for maxW > 0 && B[maxW] == 0 {
			maxW--
		}
	}

	maxVP := -1
	for j := 1; j < Words*64; j++ {
		word_j := j / 64
		bit_j := j % 64
		if (B[word_j] & (uint64(1) << bit_j)) != 0 {
			var vp int
			if j <= n {
				vp = P[j] - j + 1
			} else {
				vp = P[n] - j + 1
				if vp > maxVP {
					maxVP = vp
				}
				break
			}
			if vp > maxVP {
				maxVP = vp
			}
		}
	}

	fmt.Println(maxVP)
}
```