{-# LANGUAGE RecordWildCards #-}
import Data.ByteString.Char8 as BC (getLine, words, readInt)
import Prelude hiding (getLine, words)
import Data.List hiding (words)
import Data.Function (on)
import qualified Data.Map.Strict as M
import Data.Maybe (fromJust)
import Control.Monad
import Control.Arrow

main = do
    n <- readLn
    xs <- map (fst . fromJust . readInt) . words <$> getLine
    mapM_ print . fill n . solve . groupMnts $ xs
    where
        fill n xs = let filler = M.fromAscList . zip [1..n] $ repeat 0
                        filled = (M.fromAscList xs) `M.union` filler
                        in M.elems filled

type Stones = Int
type Index = Int

sample = [1,2,1,3,2,4,2,5,8,1] :: [Stones]
sample2 = [1,2]

data Group = Group { _leftMost :: Index, _stones :: Stones, _mnts :: Int }
           deriving (Show)

groupMnts :: [Stones] -> [Group]
groupMnts = joinMountains . groupByStones . attachIndex
    where
        attachIndex = flip zip [1..]
        groupByStones
            = groupBy ((==) `on` fst) . sortBy (compare `on` first negate)
        joinMountains
            = map (\ xs@((s,i):_)  -> Group i s (length xs))

mergeGroups :: Group -> Group -> Group
mergeGroups (Group i s m) (Group i' s' m')
    = if s == s'
         then Group (min i i') s (m+m')
         else error "cannot merge and I was too lazy to use Maybe"

solve :: [Group] -> [(Int,Int)]
solve = join . consume
    -- fixme
    where
        join = foldl' f []
        f [] n = [n]
        f acc@((i,n):r) x@(i',n') = if i == i' then (i,n+n'):r else x:acc
        consume [] = []
        consume [Group{..}] = [ (_leftMost, _stones * _mnts) ]
        consume (g0:g1:rest) =
            (_leftMost g0, (_stones g0 - _stones g1)* _mnts g0)
                : consume (mergeGroups g0{_stones=_stones g1} g1:rest)