#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2e9;
const long long INFLL = 1e18;
const int MAX_N = 1;
int N;
vector<long long> v;
struct SEG {
  struct NODE {
    int l, r;
    long long data;
  };
  vector<NODE> seg;
  int SZ;
  void add() { seg.push_back((NODE){-1, -1, (long long)0}); }
  void Init(int x) {
    SZ = x;
    add();
    init(0, 1, SZ);
  }
  void init(int idx, int s, int e) {
    if (s == e) return;
    seg[idx].l = seg.size();
    add();
    seg[idx].r = seg.size();
    add();
    init(seg[idx].l, s, (s + e) / 2);
    init(seg[idx].r, (s + e) / 2 + 1, e);
  }
  void Update(int x, long long y) { update(0, 1, SZ, x, y); }
  void update(int idx, int s, int e, int x, long long y) {
    seg[idx].data += y;
    if (s == e) return;
    if (x <= (s + e) / 2)
      update(seg[idx].l, s, (s + e) / 2, x, y);
    else
      update(seg[idx].r, (s + e) / 2 + 1, e, x, y);
  }
  long long Sum(int x, int y) { return sum(0, 1, SZ, x, y); }
  long long sum(int idx, int s, int e, int x, int y) {
    if (x <= s && e <= y)
      return seg[idx].data;
    else if (x > e || y < s)
      return 0;
    return sum(seg[idx].l, s, (s + e) / 2, x, y) +
           sum(seg[idx].r, (s + e) / 2 + 1, e, x, y);
  }
};
SEG Seg;
vector<long long> ans;
set<int> st;
int main() {
  cin >> N;
  Seg.Init(N);
  for (int i = 0; i < N; i++) {
    long long x;
    scanf("%lld", &x);
    v.push_back(x);
  }
  for (int i = 1; i <= N; i++) {
    Seg.Update(i, i);
    st.insert(i);
  }
  while (!v.empty()) {
    long long x = v.back();
    v.pop_back();
    int s = 1, e = N, m;
    while (s < e) {
      m = (s + e) / 2 + 1;
      if (Seg.Sum(1, m - 1) > x) {
        e = m - 1;
      } else {
        s = m;
      }
    }
    s = (*st.lower_bound(s));
    st.erase(s);
    ans.push_back(s);
    Seg.Update(s, -s);
  }
  while (!ans.empty()) {
    printf("%d ", (int)ans.back());
    ans.pop_back();
  }
  return 0;
}

### Prompt

Please provide a Cpp coded solution to the problem described below:

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.

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1000000007;
const int INF = 2e9;
const long long INFLL = 1e18;
const int MAX_N = 1;
int N;
vector<long long> v;
struct SEG {
  struct NODE {
    int l, r;
    long long data;
  };
  vector<NODE> seg;
  int SZ;
  void add() { seg.push_back((NODE){-1, -1, (long long)0}); }
  void Init(int x) {
    SZ = x;
    add();
    init(0, 1, SZ);
  }
  void init(int idx, int s, int e) {
    if (s == e) return;
    seg[idx].l = seg.size();
    add();
    seg[idx].r = seg.size();
    add();
    init(seg[idx].l, s, (s + e) / 2);
    init(seg[idx].r, (s + e) / 2 + 1, e);
  }
  void Update(int x, long long y) { update(0, 1, SZ, x, y); }
  void update(int idx, int s, int e, int x, long long y) {
    seg[idx].data += y;
    if (s == e) return;
    if (x <= (s + e) / 2)
      update(seg[idx].l, s, (s + e) / 2, x, y);
    else
      update(seg[idx].r, (s + e) / 2 + 1, e, x, y);
  }
  long long Sum(int x, int y) { return sum(0, 1, SZ, x, y); }
  long long sum(int idx, int s, int e, int x, int y) {
    if (x <= s && e <= y)
      return seg[idx].data;
    else if (x > e || y < s)
      return 0;
    return sum(seg[idx].l, s, (s + e) / 2, x, y) +
           sum(seg[idx].r, (s + e) / 2 + 1, e, x, y);
  }
};
SEG Seg;
vector<long long> ans;
set<int> st;
int main() {
  cin >> N;
  Seg.Init(N);
  for (int i = 0; i < N; i++) {
    long long x;
    scanf("%lld", &x);
    v.push_back(x);
  }
  for (int i = 1; i <= N; i++) {
    Seg.Update(i, i);
    st.insert(i);
  }
  while (!v.empty()) {
    long long x = v.back();
    v.pop_back();
    int s = 1, e = N, m;
    while (s < e) {
      m = (s + e) / 2 + 1;
      if (Seg.Sum(1, m - 1) > x) {
        e = m - 1;
      } else {
        s = m;
      }
    }
    s = (*st.lower_bound(s));
    st.erase(s);
    ans.push_back(s);
    Seg.Update(s, -s);
  }
  while (!ans.empty()) {
    printf("%d ", (int)ans.back());
    ans.pop_back();
  }
  return 0;
}

```