#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int X = 1e6 + 228, M = 300 + 2;
constexpr ll infLL = 1e18;

ll dp_[2 * X + 1], a_[2 * M + 1], b_[2 * M + 1], dq_[2 * X + 1];
auto dp = dp_ + X, dq = dq_ + X, a = a_ + M, b = b_ + M;

struct MaxQueue {
    deque<ll> qwq;

    void ins(ll x) {
        if (x < -infLL) {
            return;
        }
        while (!qwq.empty() && qwq.back() < x) {
            qwq.pop_back();
        }
        qwq.push_back(x);
    }

    void del(ll x) {
        if (x < -infLL) {
            return;
        }
        if (!qwq.empty() && qwq.front() == x) {
            qwq.pop_front();
        }
    }

    ll top() {
        return qwq.empty() ? ll(-3e18) : qwq.front();
    }

    void clear() {
        qwq.clear();
    }
};

MaxQueue q[M];

int mod(int x, int y) {
    if (y < 0) {
        x *= -1, y *= -1;
    }
    if ((x %= y) < 0) {
        x += y;
    }
    return x;
}

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

    int m;
    ll L;
    cin >> m >> L;

    fill(begin(dp_), end(dp_), -3e18);

    for (int i = -m; i <= m; ++i) {
        cin >> a[i];
    }

    if (L < 0 && accumulate(a - m, a + 1, 0LL) == 0) {
        cout << "impossible\n";
        return 0;
    }

    if (L < 0) {
        L = -L;
        reverse(a - m, a + m + 1);
    }

    ll s = 0, cnt = 0;

    for (int i = -m; i <= 0; ++i) {
        b[i] = a[i];
        s += a[i] * i;
    }

    for (int i = 1; i <= m; ++i) {
        b[i] = min(a[i], (max(0LL, L - s) + i - 1) / i);
        s += b[i] * i;
    }

    for (int i = -m; i < 0 && s < L; ++i) {
        ll c = s - a[i] * i;
        if (c >= L) {
            ll now = (L - s - i - 1) / -i;
            assert(s - i * now >= L && s - i * (now - 1) < L);
            b[i] -= now;
            s -= i * now;
        } else {
            s -= a[i] * i;
            b[i] = 0;
        }
    }

    cnt = accumulate(b - m, b + m + 1, 0LL);

    if (s < L) {
        cout << "impossible\n";
        return 0;
    }

    dp[0] = 0;

    auto canAdd = [&](int l, ll cnt) {
        if (cnt == 0) {
            return;
        }
        copy(dp - X, dp + X + 1, dq - X);
        for (int i = 0; i < abs(l); ++i) {
            q[i].clear();
        }
        cnt *= abs(l);
        if (l > 0) {
            for (int x = -X + 1, rem = mod(x, l), div = x / l; x < X; ++x, rem = rem == l - 1 ? 0 : rem + 1, div = rem == 0 ? div + 1 : div) {
                dp[x] = max(dq[x], q[rem].top() + div);
//                if (dq[x] > -infLL) {
                    q[rem].ins(dq[x] -= div);
//                }
                if (x - cnt > -X) {
                    q[rem].del(dq[x - cnt]);
                }
            }
        } else if (l < 0) {
            l = -l;
            for (int x = X - 1, rem = mod(x, l), div = x / l; x > -X; --x, div = rem == 0 ? div - 1 : div, rem = rem == 0 ? l - 1 : rem - 1) {
                dp[x] = max(dq[x], q[rem].top() - div);
//                if (dq[x] > -infLL) {
                    q[rem].ins(dq[x] += div);
//                }
                if (x + cnt * l < X) {
                    q[rem].del(dq[x + cnt]);
                }
            }
        }
    };

    auto canDelete = [&](int l, ll cnt) {
        if (cnt == 0) {
            return;
        }
        copy(dp - X, dp + X + 1, dq - X);
        for (int i = 0; i < abs(l); ++i) {
            q[i].clear();
        }
        cnt *= abs(l);
        if (l > 0) {
            for (int x = X - 1, rem = mod(x, l), div = x / l; x > -X; --x, div = rem == 0 ? div - 1 : div, rem = rem == 0 ? l - 1 : rem - 1) {
                dp[x] = max(dq[x], q[rem].top() + div);
//                if (dq[x] > -infLL) {
                    q[rem].ins(dq[x] -= div);
//                }
                if (x + cnt < X) {
                    q[rem].del(dq[x + cnt]);
                }
            }
        } else if (l < 0) {
            l = -l;
            for (int x = -X + 1, rem = mod(x, l), div = x / l; x < X; ++x, rem = rem == l - 1 ? 0 : rem + 1, div = rem == 0 ? div + 1 : div) {
                dp[x] = max(dq[x], q[rem].top() - div);
//                if (dq[x] > -infLL) {
                    q[rem].ins(dq[x] += div);
//                }
                if (x - cnt * l > -X) {
                    q[rem].del(dq[x - cnt]);
                }
            }
        }
    };

    for (int i = -m; i <= m; ++i) {
        if (i != 0) {
            canAdd(i, a[i] - b[i]);
            canDelete(i, b[i]);
        }
    }

    ll need = L - s;

    if (need <= -X || need >= X || cnt + dp[need] < 0) {
        cout << "impossible\n";
        return 0;
    }

    cout << cnt + dp[need] << '\n';

    return 0;
}