import bisect

def main():
    import sys
    input = sys.stdin.read
    data = input().split()
    n = int(data[0])
    A = list(map(int, data[1:n+1]))
    
    # Coordinate compression for Fenwick Tree
    sorted_unique = sorted(set(A))
    compress = {v: i + 1 for i, v in enumerate(sorted_unique)}
    max_rank = len(compress)
    
    class FenwickTree:
        def __init__(self, size):
            self.size = size
            self.tree = [0] * (self.size + 1)
        
        def update(self, idx, delta=1):
            while idx <= self.size:
                self.tree[idx] += delta
                idx += idx & -idx
        
        def query(self, idx):
            res = 0
            while idx > 0:
                res += self.tree[idx]
                idx -= idx & -idx
            return res
    
    ft = FenwickTree(max_rank)
    inv = 0
    for i in reversed(range(n)):
        x = A[i]
        rank = compress[x]
        inv += ft.query(rank - 1)
        ft.update(rank)
    
    sorted_A = sorted(A)
    count_less = []
    count_greater = []
    for x in A:
        cl = bisect.bisect_left(sorted_A, x)
        cg = len(sorted_A) - bisect.bisect_right(sorted_A, x)
        count_less.append(cl)
        count_greater.append(cg)
    
    right_rotations = [inv]
    for i in reversed(range(n-1)):
        x = A[i+1]
        cl = count_less[i+1]
        cg = count_greater[i+1]
        new_inv = right_rotations[-1] - cg + cl
        right_rotations.append(new_inv)
    
    output = []
    for k in range(n):
        pos = (n - k) % n
        output.append(str(right_rotations[pos]))
    
    print('\n'.join(output))

if __name__ == '__main__':
    main()