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>).

from math import sqrt,ceil
from collections import defaultdict

def dfs(n,hash,flag,l,tot,final,visited):

    if n <=0 or n>tot:

        return 0


    if flag == 0:



      if (n,0) in visited:

          return -10**18
      else:

          visited.add((n,0))

      if (n,0) in seen:

          return hash[(n,0)]
      else:
          seen.add((n,0))


      z = dfs(n+l[n-1],hash,1,l,tot,final+l[n-1],visited)

      hash[(n,0)] = z+l[n-1]
      return  hash[(n,0)]
    else:


      if (n,1) in visited:
          return -10**18
      else:
          visited.add((n,1))

      if (n,1) in seen:
          return hash[(n,1)]
      else:
          seen.add((n,1))

      z =  dfs(n-l[n-1],hash,0,l,tot,final+l[n-1],visited)

      hash[(n,1)] = z+l[n-1]
      return  hash[(n,1)]






def solve():

     n = int(input())
     l = [0]+list(map(int,input().split()))
     boo = defaultdict(bool)
     hash = defaultdict(int)
     ans = []

     for i in range(1,n):
         y = 0
         x = 1
         l[0] = i
         visited = set()

         if (1,0) in seen:
             seen.remove((1,0))

         if (1,1) in seen:
             seen.remove((1,1))

         if x>n:
             ans.append(y)
         else:
             z = dfs(x,hash,0,l,n,y,visited)
             if z<0:
                 ans.append(-1)
             else:

               ans.append(z)

     for i in ans:
         print(i)



seen = set()
solve()



