{-# 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
