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

#define debug(x) cerr << (#x) << ' ' << (x) << endl

const int INF = 1e9;
using ll = long long;

//struct SegmentTree {
//    int pow;
//    vector<int> mn, add;
//
//    SegmentTree(vector<int> &a) {
//        pow = 1;
//        while (pow < a.size()) {
//            pow *= 2;
//        }
//        mn.resize(2 * pow, INF);
//        add.resize(2 * pow);
//        for (int i = 0; i < a.size(); ++i) {
//            mn[pow + i] = a[i];
//        }
//        for (int i = pow - 1; i > 0; --i) {
//            mn[i] = f(mn[2 * i], mn[2 * i + 1]);
//        }
//    }
//
//    int get(int l, int r) {
//        return get(1, 0, pow, l, r);
//    }
//
//    int get(int v, int tl, int tr, int l, int r) {
//        if (l <= tl && tr <= r) {
//            return mn[v];
//        }
//        if (tr <= l || r <= tl) {
//            return INF;
//        }
//        int tm = (tl + tr) / 2;
//        push(v);
//        return f(get(2 * v, tl, tm, l, r), get(2 * v + 1, tm, tr, l, r));
//    }
//
//    void upd(int l, int r, int d) {
//        upd(1, 0, pow, l, r, d);
//    }
//
//    void upd(int v, int tl, int tr, int l, int r, int d) {
//        if (l <= tl && tr <= r) {
//            apply(v, d);
//            return;
//        }
//        if (tr <= l || r <= tl) {
//            return;
//        }
//        int tm = (tl + tr) / 2;
//        push(v);
//        upd(2 * v, tl, tm, l, r, d);
//        upd(2 * v + 1, tm, tr, l, r, d);
//        mn[v] = f(mn[2 * v], mn[2 * v + 1]);
//    }
//
//    void push(int v) {
//        apply(2 * v, add[v]);
//        apply(2 * v + 1, add[v]);
//        add[v] = 0;
//    }
//
//    void apply(int v, int x) {
//        mn[v] += x;
//        add[v] += x;
//    }
//
//    int f(int a, int b) {
//        return min(a, b);
//    }
//};

template <class T>
struct SegmentTreeMaxSet {
    int pow;
    T neutral;
    vector<T> seg;

    SegmentTreeMaxSet(int n, T zero) {
        neutral = zero;
        pow = 1;
        while (pow <= n) {
            pow *= 2;
        }
        seg.resize(2 * pow, zero);
    }

    T get(int l, int r) {
        if (l >= r) {
            return neutral;
        }
        return get(1, 0, pow, l, r);
    }

    T get(int v, int tl, int tr, int l, int r) {
        if (l >= tr || r <= tl) {
            return neutral;
        }
        if (l <= tl && tr <= r) {
            return seg[v];
        }
        int tm = (tl + tr) / 2;
        return f(get(2 * v, tl, tm, l, r), get(2 * v + 1, tm, tr, l, r));
    }

    void set(int x, int value) {
        set(1, 0, pow, x, value);
    }

    void set(int v, int tl, int tr, int x, int value) {
        if (v >= pow) {
            seg[v] = value;
            return;
        }
        int tm = (tl + tr) / 2;
        if (x < tm) {
            set(2 * v, tl, tm, x, value);
        } else {
            set (2 * v + 1, tm, tr, x, value);
        }
        seg[v] = f(seg[2 * v], seg[2 * v + 1]);
    }

    T f(T a, T b) {
        return max(a, b);
    }
};

template <class T>
struct SegmentTreeSumAddPoint {
    int pow;
    T neutral;
    vector<T> seg;

    SegmentTreeSumAddPoint(int n, T zero) {
        neutral = zero;
        pow = 1;
        while (pow <= n) {
            pow *= 2;
        }
        seg.resize(2 * pow, zero);
    }

    T get(int l, int r) {
        if (l >= r) {
            return neutral;
        }
        return get(1, 0, pow, l, r);
    }

    T get(int v, int tl, int tr, int l, int r) {
        if (l >= tr || r <= tl) {
            return neutral;
        }
        if (l <= tl && tr <= r) {
            return seg[v];
        }
        int tm = (tl + tr) / 2;
        return f(get(2 * v, tl, tm, l, r), get(2 * v + 1, tm, tr, l, r));
    }

    void add(int x, int value) {
        set(1, 0, pow, x, value);
    }

    void set(int v, int tl, int tr, int x, int value) {
        seg[v] += value;
        if (v >= pow) {
            return;
        }
        int tm = (tl + tr) / 2;
        if (x < tm) {
            set(2 * v, tl, tm, x, value);
        } else {
            set (2 * v + 1, tm, tr, x, value);
        }
    }

    T f(T a, T b) {
        return a + b;
    }
};

int LOG = 22;

void solve() {
    int n, c;
    cin >> n >> c;
    vector<ll> d(2 * n);
    vector<ll> pref(2 * n + 1);
    for (int i = 0; i < n; ++i) {
        cin >> d[i];
        pref[i + 1] = pref[i] + d[i];
    }
    for (int i = 0; i < n; ++i) {
        d[i + n] = d[i];
        pref[i + n + 1] = pref[n + i] + d[i];
    }
    vector<vector<int>> st(LOG, vector<int>(n, n));
    for (int i = 0; i < n; ++i) {
        int l = 0;
        int r = n;
        while (l + 1 < r) {
            int m = (l + r) / 2;
            if (pref[i + m] - pref[i] >= c) {
                r = m;
            } else {
                l = m;
            }
        }
        st[0][i] = r;
    }
    for (int i = 0; i < LOG - 1; ++i) {
        for (int j = 0; j < n; ++j) {
            int cur = st[i][j];
            if (cur < n) {
                int nxt = (j + cur) % n;
                int upd = cur + st[i][nxt];
                if (upd < n) {
                    st[i + 1][j] = upd;
                }
            }
        }
    }
    vector<int> pow(LOG);
    pow[0] = 1;
    for (int i = 0; i < LOG - 1; ++i) {
        pow[i + 1] = pow[i] * 2;
    }
    for (int i = 0; i < n; ++i) {
        int ans = 0;
        int cur = 0;
        int curp = i;
        for (int j = LOG - 1; j >= 0; --j) {
            if (st[j][curp] + cur < n) {
                cur += st[j][curp];
                curp = (curp + st[j][curp]) % n;
                ans += pow[j];
            }
        }
        cout << ans << " ";
    }
    cout << "\n";
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int t = 1;
//    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}