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 Haskell (GHC 8.8.3) (judge verdict: Accepted)

{-# LANGUAGE BangPatterns #-}

import Control.Monad
import qualified Data.ByteString.Builder as B
import qualified Data.ByteString.Char8 as C
import Data.List
import Data.Monoid
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Unboxed.Mutable as UM
import Debug.Trace
import System.IO


r :: Int -> IO (U.Vector Int)
r n = U.unfoldrN n (C.readInt . C.dropWhile (==' ')) <$> C.getLine

r' :: IO [Int]
r'  =   unfoldr    (C.readInt . C.dropWhile (==' ')) <$> C.getLine

printV :: (Show a, U.Unbox a) => U.Vector a -> IO ()
printV v =
    let showB = B.string8 . show
    in  B.hPutBuilder stdout $ 
            U.foldl' (\ac a -> ac <> B.char8 ' ' <> showB a) (showB $ U.head v) (U.tail v)
                <> B.char8 '\n'

main :: IO ()
main = do
    [n,k] <- r'
    as <- r n
    res <- (k `timesUntilM` solve) (U.all (==n)) as
    printV res

solve :: U.Vector Int -> IO (U.Vector Int)
solve v = do
    let on  = U.imap (\i a -> max 1 ((i+1)-a)) v
        off = U.imap (\i a -> min (U.length v) (i+1+a)) v

    onI  <- UM.replicate (U.length v) 0
    offI <- UM.replicate (U.length v) 0
    U.forM_ on  (UM.modify onI  succ . pred)
    U.forM_ off (UM.modify offI succ . pred)
    onIF  <- U.freeze onI
    offIF <- U.freeze offI
    let difs = U.zipWith (-) (U.tail onIF) offIF
    return $ U.scanl' (+) (U.head onIF) difs

timesUntilM :: Monad m => Int -> (a -> m a) -> (a -> Bool) -> a -> m a
timesUntilM  0 f g x         = return x
timesUntilM !n f g x | g x   = return x
timesUntilM !n f g x         = f x >>= timesUntilM (n-1) f g