#include <bits/stdc++.h>
using namespace std;
using ll = long long;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N;
    cin >> N;
    vector<ll> A(N+1);
    for (int i = 0; i <= N; i++) {
        cin >> A[i];
    }
    
    // Total vertices and sum of degrees
    ll V = 0, sumD = 0;
    for (int d = 0; d <= N; d++) {
        V += A[d];
        sumD += A[d] * d;
    }
    
    // Basic necessary checks
    if ((sumD & 1) || sumD > 2 * (V - 1)) {
        cout << "No\n";
        return 0;
    }
    // Max degree
    for (int d = V; d <= N; d++) {
        if (A[d] > 0) {
            cout << "No\n";
            return 0;
        }
    }
    
    // Build degree groups (degree value, count) in descending order
    vector<int> degs;
    vector<ll> cnt;
    for (int d = N; d >= 0; d--) {
        if (A[d] > 0) {
            degs.push_back(d);
            cnt.push_back(A[d]);
        }
    }
    int m = degs.size();
    
    // Prefix sums of counts and degree*counts
    vector<ll> pc(m), ps(m);
    for (int i = 0; i < m; i++) {
        pc[i] = cnt[i] + (i ? pc[i-1] : 0);
        ps[i] = cnt[i] * degs[i] + (i ? ps[i-1] : 0);
    }
    
    // Erdős–Gallai check at each prefix boundary
    for (int t = 0; t < m; t++) {
        ll k = pc[t];           // number of vertices in prefix
        ll leftSum = ps[t];     // sum of degrees in prefix
        // Compute right side: k*(k-1) + sum_{rem} min(d_i, k)
        ll rhs = k * (k - 1);
        if (k < 0 || k > V) { // sanity
            cout << "No\n";
            return 0;
        }
        if (t == m-1) {
            // no remaining vertices
        } else {
            // binary search for first index p > t where degs[p] <= k
            int l = t+1, r = m;
            while (l < r) {
                int mid = (l + r) >> 1;
                if (degs[mid] > k) l = mid + 1;
                else r = mid;
            }
            int p = l;
            // big degrees > k in [t+1..p-1]
            ll cntBig = (p-1 >= t+1) ? (pc[p-1] - pc[t]) : 0;
            // small degrees <= k in [p..m-1]
            ll sumSmall = ps[m-1] - (p-1 >= 0 ? ps[p-1] : 0);
            rhs += cntBig * k + sumSmall;
        }
        if (leftSum > rhs) {
            cout << "No\n";
            return 0;
        }
    }
    
    cout << "Yes\n";
    return 0;
}