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>).
n = int(input())
t = [0, 0]
t += list(map(int, input().split()))
n += 1
a = [0] * n
b = [0] * n
n -= 1
a[1] = b[1] = -1

#print(t, a, b)

def calc(s, a, b, l):
	global t
	l.reverse()
	j = 0
	n = len(l)
	
	while True:
		s += t[l[j]]
		a[l[j]] = s
		j += 1
		if j == n:
			return
		
		s += t[l[j]]
		b[l[j]] = s
		j += 1
		if j == n:
			return

			
def calc2(i, k):
	global a, b
	l = []
	if k:
		a[i] = -1
		l.append(i)
		i += t[i]
		
	while True:
		if i > n:
			return calc(0, a, b, l)
		if b[i] > 0:
			return calc(b[i], a, b, l)
		if b[i] == -1:
			return
		b[i] = -1
		l.append(i)
		i -= t[i]
		if i < 1:
			return calc(0, b, a, l)
		if a[i] > 0:
			return calc(a[i], b, a, l)
		if a[i] == -1:
			return
		a[i] -= 1
		l.append(i)
		i += t[i]

for i in range(2, n + 1):
	if a[i] == 0:
		calc2(i, True)
	if b[i] == 0:
		calc2(i, False)

for i in range(1, n):
	if b[i + 1] > 0:
		t[i] = i + b[i + 1]
	else:
		t[i] = -1

#print(t, a, b)
		
print('\n'.join(map(str, t[1:n])))