output_description: Print N lines. The i-th line should contain the number of the occurrences of
  the integer i in the lexicographically smallest sequence that can be
  constructed.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 ... a_{N}
attempt: import bisect
  import heapq
  import itertools
  import math
  import operator
  import os
  import re
  import string
  import sys
  from collections import Counter, deque, defaultdict
  from copy import deepcopy
  from decimal import Decimal
  from fractions import gcd
  from functools import lru_cache, reduce
  from operator import itemgetter, mul, add, xor
  
  import numpy as np
  
  if os.getenv("LOCAL"):
      sys.stdin = open("_in.txt", "r")
  
  sys.setrecursionlimit(2147483647)
  INF = float("inf")
  IINF = 10**18
  MOD = 10**9 + 7
  
  
  class BinaryIndexedTree:
      # http://hos.ac/slides/20140319_bit.pdf
      def __init__(self, size):
          """
          :param int size:
          """
          self._bit = [0] * size
          self._size = size
  
      def add(self, i, w):
          """
          i 番目に w を加える
          :param int i:
          :param int w:
          :return:
          """
          x = i + 1
          while x <= self._size:
              self._bit[x - 1] += w
              x += x & -x
  
      def sum(self, i):
          """
          0 番目から i 番目までの合計
          :param int i:
          :return:
          """
          ret = 0
          x = i + 1
          while x > 0:
              ret += self._bit[x - 1]
              x -= x & -x
          return ret
  
      def __len__(self):
          return self._size
  
  
  N = int(sys.stdin.readline())
  A = list(map(int, sys.stdin.readline().split()))
  A = np.array(A, dtype=int)
  ans = np.zeros(N, dtype=int)
  
  # for i in range(N):
  #     if A[i] <= 0:
  #         continue
  #     ans[i] = np.minimum(A, A[i]).sum()
  #     A = np.maximum(0, A - A[i])
  # print(ans)
  
  counts = Counter(A)
  counts[0] = 0
  counts[IINF] = 0
  keys = list(sorted(counts.keys()))
  
  ki = 0
  cnt = 0
  s = 0
  for i in range(N):
      if A[i] - s <= 0:
          continue
      m = A[i]
      # s 以上 m 以下のやつの合計
      p = s
      while keys[ki] <= m:
          ans[i] += (keys[ki] - p) * (N - cnt)
          p = keys[ki]
          cnt += counts[keys[ki]]
          ki += 1
  
      s = A[i]
  
  print(*ans, sep="\n")
  # [10  7  0  4  0  3  0  2  3  0]
  
problem_description: Statement
  
  Snuke loves constructing integer sequences.
  
  There are N piles of stones, numbered 1 through N. The pile numbered i
  consists of a_i stones.
  
  Snuke will construct an integer sequence s of length Σa_i, as follows:
  
    1. Among the piles with the largest number of stones remaining, let x be the index of the pile with the smallest index. Append x to the end of s.
    2. Select a pile with one or more stones remaining, and remove a stone from that pile.
    3. If there is a pile with one or more stones remaining, go back to step 1. Otherwise, terminate the process.
  
  We are interested in the lexicographically smallest sequence that can be
  constructed. For each of the integers 1,2,3,...,N, how many times does it
  occur in the lexicographically smallest sequence?
samples: [{"input": "2\n    1 2", "output": "2\n    1\n    \n\nThe lexicographically smallest sequence is constructed as follows:\n\n  * Since the pile with the largest number of stones remaining is pile 2, append 2 to the end of s. Then, remove a stone from pile 2.\n  * Since the piles with the largest number of stones remaining are pile 1 and 2, append 1 to the end of s (we take the smallest index). Then, remove a stone from pile 2.\n  * Since the pile with the largest number of stones remaining is pile 1, append 1 to the end of s. Then, remove a stone from pile 1.\n\nThe resulting sequence is (2,1,1). In this sequence, 1 occurs twice, and 2\noccurs once.\n\n* * *"}, {"input": "10\n    1 2 1 3 2 4 2 5 8 1", "output": "10\n    7\n    0\n    4\n    0\n    3\n    0\n    2\n    3\n    0"}]