human
Give me a Python code to print n integers p_{1}, p_{2}, …, p_{n} — the elements of the restored permutation given the following:
An array of integers p_{1},p_{2}, …,p_{n} is called a permutation if it contains each number from 1 to n exactly once. For example, the following arrays are permutations: [3,1,2], [1], [1,2,3,4,5] and [4,3,1,2]. The following arrays are not permutations: [2], [1,1], [2,3,4].

There is a hidden permutation of length n.

For each index i, you are given s_{i}, which equals to the sum of all p_{j} such that j < i and p_{j} < p_{i}. In other words, s_i is the sum of elements before the i-th element that are smaller than the i-th element.

Your task is to restore the permutation.

Input

The first line contains a single integer n (1 ≤ n ≤ 2 ⋅ 10^{5}) — the size of the permutation.

The second line contains n integers s_{1}, s_{2}, …, s_{n} (0 ≤ s_{i} ≤ (n(n-1))/(2)).

It is guaranteed that the array s corresponds to a valid permutation of length n.

Output

Print n integers p_{1}, p_{2}, …, p_{n} — the elements of the restored permutation. We can show that the answer is always unique.

Examples

Input

3
0 0 0

Output

3 2 1

Input

2
0 1

Output

1 2

Input

5
0 1 1 1 10

Output

1 4 3 2 5

Note

In the first example for each i there is no index j satisfying both conditions, hence s_i are always 0.

In the second example for i = 2 it happens that j = 1 satisfies the conditions, so s_2 = p_1.

In the third example for i = 2, 3, 4 only j = 1 satisfies the conditions, so s_2 = s_3 = s_4 = 1. For i = 5 all j = 1, 2, 3, 4 are possible, so s_5 = p_1 + p_2 + p_3 + p_4 = 10.
Solve the task in PYTHON3.
assistant
#Here is Python code to print n integers p_{1}, p_{2}, …, p_{n} — the elements of the restored permutation.

# https://codeforces.com/contest/1208/problem/D

from sys import stdin, stdout
input = stdin.readline
# print = stdout.write

# si is the sum of elements before the i-th element that are smaller than the i-th element.

# For every i from N to 1, let's say the value of the si is x.
# So it means there are k smallest unused numbers whose sum is x.
# We simply put the k+1st number in the output permutation at this i, and continue to move left.

# BIT and binary lifting
# https://codeforces.com/contest/1208/submission/59526098

class BIT:
    def __init__(self, nums):
        # we store the sum information in bit 1.
        # so the indices should be 1 based.
        # here we assume nums[0] = 0
        self.nums = [0] * (len(nums))
        for i, x in enumerate(nums):
            if i == 0:
                continue
            self.update(i, x)

    def low_bit(self, x):
        return x & (-x)

    def update(self, i, diff):
        while i < len(self.nums):
            self.nums[i] += diff
            i += self.low_bit(i)

    def prefix_sum(self, i):
        ret = 0
        while i != 0:
            ret += self.nums[i]
            i -= self.low_bit(i)
        return ret

    def search(self, x):
        # find the index i such that prefix_sum(i) == x
        cur_index, cur_sum = 0, 0
        delta = len(self.nums) - 1
        while delta - self.low_bit(delta):
            delta -= self.low_bit(delta)

        while delta:            
            m = cur_index + delta
            if m < len(self.nums):
                sm = cur_sum + self.nums[m]
                if sm <= x:
                    cur_index, cur_sum = m, sm
            delta //= 2
        return cur_index + 1

n = int(input())
bit = BIT(range(n+1))

ans = [0 for _ in range(n)]
nums = list(map(int, input().split()))
for i in range(n - 1, -1, -1):
    index = bit.search(nums[i])
    bit.update(index, -index)
    ans[i] = index
print(*ans)