Problem:
Score : 600 points

Problem Statement

Given is an integer sequence of length N+1: A_0, A_1, A_2, \ldots, A_N. Is there a binary tree of depth N such that, for each d = 0, 1, \ldots, N, there are exactly A_d leaves at depth d? If such a tree exists, print the maximum possible number of vertices in such a tree; otherwise, print -1.

Notes

A binary tree is a rooted tree such that each vertex has at most two direct children.

A leaf in a binary tree is a vertex with zero children.

The depth of a vertex v in a binary tree is the distance from the tree's root to v. (The root has the depth of 0.)

The depth of a binary tree is the maximum depth of a vertex in the tree.

Constraints

0 \leq N \leq 10^5

0 \leq A_i \leq 10^{8} (0 \leq i \leq N)

A_N \geq 1

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_0 A_1 A_2 \cdots A_N

Output

Print the answer as an integer.

Sample Input 1

3
0 1 1 2

Sample Output 1

7

Below is the tree with the maximum possible number of vertices. It has seven vertices, so we should print 7.

Sample Input 2

4
0 0 1 0 2

Sample Output 2

10

Sample Input 3

2
0 3 1

Sample Output 3

-1

Sample Input 4

1
1 1

Sample Output 4

-1

Sample Input 5

10
0 0 1 1 2 3 5 8 13 21 34

Sample Output 5

264

Solution in Julia (1.4.0) (judge verdict: Runtime Error)

const double = Float64
const int = Int128
 
parseint(x) = parse(int, x)
readint() = map(parseint, split(readline()))
 

function main(a::Int128)
  a = a*a

  N = readint()[1]
  A = readint()
 
  if A[0] && N==0
    println(-1)
    return
  end
  if A[1] == 1
    if N==0
      println(1)
      return
    else
      println(-1)
      return
    end
  end
 
  sum = 1
  parent = 1
 
  pmaxs = Vector{int}(undef,N+1)
  pmaxs[1] = 1
 
  for i in 2:N+1
    nmax = parent * 2
    if A[i] > nmax 
      #println(pmaxs)
      println(-1)
      return
    end
    parent = min(nmax - A[i],a)
    pmaxs[i] = parent
  end 
 
  #sum = 1
  sum = 1+ A[N+1]
  ch = A[N+1]
  for i in N:-1:2
    sum += A[i] + min(pmaxs[i],ch)
    ch = A[i] + min(pmaxs[i],ch) 
  end 
 
  println(sum)
 
  
end
 
a = Vector{Int128}(undef,1)
a[1] = 2^62
main(a[1])