human
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.
 ... Give me a Python program to print n integers p_{1}, p_{2}, …, p_{n} — the elements of the restored permutation?
assistant
#Here is Python program to print n integers p_{1}, p_{2}, …, p_{n} — the elements of the restored permutation.

_ = input()
x = [int(i) for i in input().split()]

res = []

from math import log

class SegmentTree(object):

    def __init__(self, nums):
        self.arr = nums
        self.l = len(nums)
        self.tree = [0] * self.l + nums
        for i in range(self.l - 1, 0, -1):
            self.tree[i] = self.tree[i << 1] + self.tree[i << 1 | 1]

    def update(self, i, val):
        n = self.l + i
        self.tree[n] = val
        while n > 1:
            self.tree[n >> 1] = self.tree[n] + self.tree[n ^ 1]
            n >>= 1

    def query(self, i, j):
        m = self.l + i
        n = self.l + j
        res = 0
        while m <= n:
            if m & 1:
                res += self.tree[m]
                m += 1
            m >>= 1
            if n & 1 == 0:
                res += self.tree[n]
                n -= 1
            n >>= 1
        return res

tree = SegmentTree(list(range(1, len(x) + 1)))
org = len(x)
while x:
    q = x.pop()

    lo = 0
    hi = org - 1

    while lo < hi:
        mid = (lo + hi) // 2
        # print(lo, hi, mid)
        sm = tree.query(0, mid)
        # print(sm, mid)
        if sm > q:
            hi = mid
        else:
            lo = mid + 1
    # print(tree.arr, lo, hi)
    idx = tree.arr[lo]
    # print(idx)
    tree.update(lo, 0)
    res.append(idx)

print(' '.join(str(i) for i in res[::-1]))