Farmer John has just given the cows a program to play with! The program contains two integer variables, *x* and *y*, and performs the following operations on a sequence *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> of positive integers:
 1.  Initially, *x* = 1 and *y* = 0. If, after any step, *x* ≤ 0 or *x* &gt; *n*, the program immediately terminates. 1.  The program increases both *x* and *y* by a value equal to *a*<sub class="lower-index">*x*</sub> simultaneously. 1.  The program now increases *y* by *a*<sub class="lower-index">*x*</sub> while decreasing *x* by *a*<sub class="lower-index">*x*</sub>. 1.  The program executes steps 2 and 3 (first step 2, then step 3) repeatedly until it terminates (it may never terminate). So, the sequence of executed steps may start with: step 2, step 3, step 2, step 3, step 2 and so on. 
The cows are not very good at arithmetic though, and they want to see how the program works. Please help them!

You are given the sequence *a*<sub class="lower-index">2</sub>, *a*<sub class="lower-index">3</sub>, ..., *a*<sub class="lower-index">*n*</sub>. Suppose for each *i* (1 ≤ *i* ≤ *n* - 1) we run the program on the sequence *i*, *a*<sub class="lower-index">2</sub>, *a*<sub class="lower-index">3</sub>, ..., *a*<sub class="lower-index">*n*</sub>. For each such run output the final value of *y* if the program terminates or -1 if it does not terminate.
The first line contains a single integer, *n* (2 ≤ *n* ≤ 2·10<sup class="upper-index">5</sup>). The next line contains *n* - 1 space separated integers, *a*<sub class="lower-index">2</sub>, *a*<sub class="lower-index">3</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">9</sup>).
INF = float('inf')
n = int(input())
aaa = [0, 0] + list(map(int, input().split()))
dp = [[0 for _ in range(n+1)] for i in range(2)]
vis = [[0 for _ in range(n+1)] for i in range(2)]
rs = [0] * (n-1)

def di(d): return 0 if d == 1 else 1


def solve(x, d):
    if dp[di(d)][x]:
        return dp[di(d)][x]

    if vis[di(d)][x]:
        return INF

    ni = x + aaa[x] * d
    if ni < 1 or ni > n:
        return aaa[x]

    vis[di(d)][x] = 1
    r = aaa[x] + solve(ni, -d)
    vis[di(d)][x] = 0
    return r


for D in [1, -1]:
    for x in range(2, n+1):
        d = D
        if dp[di(d)][x]:
            continue

        ni = x + aaa[x] * d
        path = [x]
        values = [aaa[x]]
        while ni > 1 and ni <= n:
            path.append(ni)
            if dp[di(d)][ni]:
                values.append(dp[di(d)][ni])
                d *= -1
                break

            if vis[di(d)][ni]:
                values.append(INF)
                d *= -1
                break

            vis[di(d)][ni] = 1
            values.append(aaa[ni])

            d *= -1
            ni = ni + aaa[ni] * d


        if ni == 1:
            continue

        for i in range(len(values)-2, -1, -1):
            values[i] = values[i] + values[i+1]

        while path:
            dp[di(d)][path.pop()] = values.pop()
            d *= -1


for i in range(1, n):
    aaa[1] = i
    res = solve(1, 1)
    rs[i-1] = res if res < INF else -1


print('\n'.join(map(str, rs)))