#include <bits/stdc++.h>
#define rep(i, n) for (ll i = 0; i < (n); ++i)
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = 1e9;

int main() {
    ll N;
    cin >> N;
    
    vector<ll> A(N + 1);
    // rep(i, N + 1) cin >> A[i];
    for (ll i = 0; i < N + 1; i++) {
        cin >> A[i];
    }

    if (N == 0) {
        if (A[0] == 1) cout << "1" << endl;
        else cout << "-1" << endl;
        return 0;
    }

    if (A[0] != 0) {
        cout << -1 << endl;
        return 0;
    }

    // int ans = 0;  // 合計のノードの数
    // int prev_children = 1;  // 深さが1つ上で葉ではないノードの数 × 2
    bool be = true;

    // rep(i, N + 1) {
    //     // output
    //     printf("children[%d], A[%d] = %d, %d\n", i, i, A[i], prev_children);

    //     // その深さにあるノードの数を足す
    //     if (i != N) ans += prev_children;
    //     else ans += A[i];

    //     // その深さの葉の数が既に取りうる数を超えていたらfalse
    //     if (prev_children < A[i]) {
    //         be = false;
    //         // cout << "here?" << endl;
    //         break;
    //     }

    //     prev_children = (prev_children - A[i]) * 2;
    // }



    vector<ll> Nmax(N + 1);

    // ll max_ = 1;
    // if (A[0] > max_) {
    //     cout << "-1" << endl;
    //     return 0;
    // }
    // max_ *= 2;

    ll inf = 10000000000000;

    Nmax[0] = 1;

    // // rep(i, N) {
    // for (ll i = 0; i < N; i++) {
    //     // if (A[i + 1] > max_) {
    //     //     cout << "-1" << endl;
    //     //     return 0;
    //     // }
    //     // max_ *= 2;

    //     Nmax[i + 1] = (Nmax[i] - A[i]) * 2;
    //     if (Nmax[i + 1] > inf) {
    //         Nmax[i + 1] = inf;
    //     }
        
    //     // if (Nmax[i + 1] < 0 || (i < N && Nmax[i + 1] <= 0)) {
    //     //     // Nmax[i + 1] = 0;
    //     //     cout << "-1" << endl;
    //     //     return 0;
    //     // }
    //     printf("Nmax[%d] = %d\n", i + 1, Nmax[i + 1]);
    // }

    for (ll i = 1; i <= N; i++) {
        Nmax[i] = Nmax[i - 1] * 2 - A[i];
        Nmax[i] = min(Nmax[i], inf);

        if (Nmax[i] < 0 || (i < N && Nmax[i] <= 0)) {
            cout << "-1" << endl;
            return 0;
        }
    }

    // ll ans = A[N];
    // ll prev = A[N];
    // for (ll i = N - 1; i >= 0; i--) {
    //     // ans += min(prev + A[i], );
    //     ll min_nodes = (prev + 1) / 2 + A[i];
    //     ll max_nodes = prev + A[i];

    //     if (min_nodes > Nmax[i]) {
    //         be = false;
    //         break;
    //     }

    //     ll num_nodes = min(Nmax[i], max_nodes);
    //     ans += num_nodes;
    //     prev = num_nodes;

    //     // printf("深さ:%dのmin, max, Nmax, real = %d, %d, %d, %d\n", i, min_nodes, max_nodes, Nmax[i], num_nodes);

    //     // ans += prev + A[i];
    //     // prev = min(Nmax[i - 1], prev + A[i]);
    // }
    // ans++;

    ll nw = 0;
    ll ans = 0;
    for (ll i = N; i >= 0; i--) {
        nw = min(nw, Nmax[i]);
        nw += A[i];
        ans += nw;
    }

    if (be) {
        cout << ans << endl;
        // cout << "-1" << endl;
    } else {
        // cout << ans << endl;
        cout << "-1" << endl;
    }
}

/*

深さiのノードの数をN[i]とすると、
N[i] = N[i + 1] + A[i]

A[N]の大きさがキーとなる。
一つの深さの最大がA[N]を超えるまでは拡大してよく、
それを超えた場合にはもうそれ以上は増えない。と言うルールにする。

再解法
N[i]の個数は前の項からnextとして与えられる。

まず、
N[i] < A[i] だったらアウト。

それ以外だったら、
next = (N[i] - A[i]) * 2

もしnextがA[N]を超えていたら、制限する。



*/


Measured memory_bytes: 4804