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.

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.

Examples

Input

3
0 1 1 2


Output

7


Input

4
0 0 1 0 2


Output

10


Input

2
0 3 1


Output

-1


Input

1
1 1


Output

-1


Input

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


Output

264
import java.util.Scanner;

public class Main {
    private static final int MOD = 1_000_000_007;
    private static final String YES = "Yes";
    private static final String NO = "No";

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int N = sc.nextInt();
        int[] A = new int[N+1];
        for (int i=0; i<N+1; i++) {
            A[i] = sc.nextInt();
        }

        System.out.println(solve2(N, A));
    }

    private static long solve2(int N, int[] A) {
        long[] maxNode = new long[N+1];
        maxNode[0] = 1;
        for (int i=1; i<N+1; i++) {
            maxNode[i] = Math.min((maxNode[i-1]-A[i-1])*2, Long.MAX_VALUE/2);

            // System.err.println("check i=" + i + ", max=" + maxNode[i]);
            if (maxNode[i] < 0) return -1;
        }


        long count = A[N];
        long childNode = A[N];
        // System.err.println("i=" + N + ", count=" + count + ", max=" + maxNode[N] + ", leaf=" + A[N] + ", child=" + childNode);
        for (int i=N-1; i>=0; i--) {
            int minNode = A[i+1]/2 + A[i+1]%2;
            if (maxNode[i] < A[i] + minNode) {
                return -1;
            }

            count += A[i];
            count += Math.min(maxNode[i]-A[i], childNode);
            childNode = Math.min(maxNode[i]-A[i], childNode) + A[i];

            // System.err.println("i=" + i + ", count=" + count + ", max=" + maxNode[i] + ", leaf=" + A[i] + ", child=" + childNode);
        }

        if (childNode != 1) return -1;

        return count;
    }
}