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.
 Can you provide 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.

from operator import add

class Stree:
    def __init__(self, f, n, default, init_data):
        self.ln = 2**(n-1).bit_length()
        self.data = [default] * (self.ln * 2)
        self.f = f
        for i, d in init_data.items():
            self.data[self.ln + i] = d
        for j in range(self.ln - 1, 0, -1):
            self.data[j] = f(self.data[j*2], self.data[j*2+1])

    def update(self, i, a):
        p = self.ln + i
        self.data[p] = a
        while p > 1:
            p = p // 2
            self.data[p] = self.f(self.data[p*2], self.data[p*2+1])

    def get(self, i, j):
        def _get(l, r, p):
            if i <= l and j >= r:
                return self.data[p]
            else:
                m = (l+r)//2
                if j <= m:
                    return _get(l, m, p*2)
                elif i >= m:
                    return _get(m, r, p*2+1)
                else:
                    return self.f(_get(l, m, p*2), _get(m, r, p*2+1))
        return _get(0, self.ln, 1)

    def find_value(self, v):
        def _find_value(l, r, p, v):
            if r == l+1:
                return l
            elif self.data[p*2] <= v:
                return _find_value((l+r)//2, r, p*2+1, v - self.data[p*2])
            else:
                return _find_value(l, (l+r)//2, p*2, v)
        return _find_value(0, self.ln, 1, v)

def main():
    n = int(input())
    sums = {i:i for i in range(n+1)}
    stree = Stree(add, n+1, 0, sums)
    ss = list(map(int, input().split()))
    ss.reverse()
    pp = []
    for s in ss:
        sval = stree.find_value(s)
        pp.append(sval)
        stree.update(sval,0)
    print(*(reversed(pp)))

if __name__ == "__main__":
    main()