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 Common Lisp (SBCL 2.0.3) (judge verdict: Accepted)

(defun main ()
  (let* ((n (read))
         (a (make-array `(,(+ n 2))))
         (b (make-array `(,(1+ n))))
         (m (make-array `(,(1+ n))))
         (2^n 1)
         (ans 0))
    ; memo
    ; (log (expt 10 8) 2) => 26.575424
    ;
    ; read
    (loop :for i :from 0 :to n
          :do (setf (aref a i) (read)))
    ;
    (setf (aref m n) (aref a n))
    (loop :for i :downfrom (1- n) :to 0
          :do (setf (aref m i) (+ (aref a i) (aref m (1+ i)))))
    ; init 
    (setf (aref a (1+ n)) 0)
    (when (> (aref a 0) 2^n)
      (format t "-1~%")
      (return-from main))
    (incf ans 2^n)
    (setf (aref b 0) (- 2^n (aref a 0)))
    (setf 2^n (* 2 1))
    ;
    (loop :for i :from 1 :to n
          :do (let* ((p (aref b (1- i)))
                     (c (aref a (1+ i)))
                     (_max (min (* 2 p) 2^n (aref m i)))
                     (_min (ceiling (/ c 2))))
                ;(format t "S: ~A P: ~A A: ~A M: ~A ~A~%" ans p (aref a i) _max _min)
                ; ex. case
                (when (or (> _min _max) (> 0 (- _max (aref a i))))
                  (format t "-1~%")
                  (return-from main))
                ;
                (cond ((= i n)
                       (incf ans (aref a i)))
                      (t
                       (incf ans _max)
                       (setf (aref b i) (- _max (aref a i)))
                       (setf 2^n (* 2 2^n))))))
    (format t "~A~%" ans)))
(main)