Problem:
Score : 500 points

Problem Statement

We have N bulbs arranged on a number line, numbered 1 to N from left to right.
Bulb i is at coordinate i.

Each bulb has a non-negative integer parameter called intensity.
When there is a bulb of intensity d at coordinate x, the bulb illuminates the segment from coordinate x-d-0.5 to x+d+0.5.
Initially, the intensity of Bulb i is A_i. We will now do the following operation K times in a row:

For each integer i between 1 and N (inclusive), let B_i be the number of bulbs illuminating coordinate i. Then, change the intensity of each bulb i to B_i.

Find the intensity of each bulb after the K operations.

Constraints

1 \leq N \leq 2 \times 10^5

1 \leq K \leq 2 \times 10^5

0 \leq A_i \leq N

Input

Input is given from Standard Input in the following format:

N K
A_1 A_2 \ldots A_N

Output

Print the intensity A{'}_i of each bulb i after the K operations to Standard Output in the following format:

A{'}_1 A{'}_2 \ldots A{'}_N

Sample Input 1

5 1
1 0 0 1 0

Sample Output 1

1 2 2 1 2

Initially, only Bulb 1 illuminates coordinate 1, so the intensity of Bulb 1 becomes 1 after the operation.
Similarly, the bulbs initially illuminating coordinate 2 are Bulb 1 and 2, so the intensity of Bulb 2 becomes 2.

Sample Input 2

5 2
1 0 0 1 0

Sample Output 2

3 3 4 4 3

Solution in C++ (GCC 9.2.1) (judge verdict: Accepted)

#ifdef DEBUG

#else

#    pragma GCC optimize("O3,no-stack-protector")
#    pragma GCC optimize("unroll-loops")

#    if __cplusplus < 201703L
#        pragma GCC target("avx")
#    else
#        pragma GCC target("avx2")
#    endif

#endif

#define _USE_MATH_DEFINES
#include <bits/stdc++.h>
#define dump(x) cout << x << endl
typedef int64_t Int;
typedef long double Ld;

using namespace std;
using Graph = vector<vector<Int>>;

template <typename T>
using vec = vector<T>;

template <typename T>
using vec2 = vector<vector<T>>;

template <typename T>
using vec3 = vector<vector<vector<T>>>;

const Ld pi = M_PI;
const Int MOD = 1000000007;
const Int INF = 1LL << 61;

Int Floor(Int a, Int b) {
    return (a - (a % b)) / b;
}

void p(const vec<Int> &a) {
    Int n = a.size();
    for (Int i = 0; i < n - 1; i++) {
        cout << setw(3) << a[i];
    }
    cout << setw(3) << a[n - 1] << endl;
}

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

    Int n, k;
    cin >> n >> k;
    vec<Int> a(n);
    for (Int i = 0; i < n; i++) {
        cin >> a[i];
    }

    if (n <= k) {
        for (Int i = 0; i < n - 1; i++) {
            cout << n << ' ';
        }
        cout << n << endl;

        return 0;
    }

    for (Int i = 0; i < k; i++) {
        bool iscon = false;
        vec<Int> aa(n);
        for (Int j = 0; j < n; j++) {
            Int L, R;
            L = clamp(j - a[j], (Int)0, (Int)n);
            R = clamp(j + a[j], (Int)0, (Int)(n - 1));

            aa[L]++;
            if (R + 1 < n) {
                aa[R + 1]--;
            }
        }
        for (Int j = 1; j < n; j++) {
            aa[j] += aa[j - 1];
        }

        a = aa;

        for (Int j = 0; j < n; j++) {
            if (a[j] < n) {
                iscon = true;
                break;
            }
        }

        if (!iscon) {
            a.assign(n, n);
            break;
        }
    }

    for (Int i = 0; i < n - 1; i++) {
        cout << a[i] << ' ';
    }
    cout << a[n - 1] << endl;

    return 0;
}