#include <bits/stdc++.h>

using namespace std;
int m  ,temp;
char tip;
int x,y;

#define priority prior

class treap{
public:
    treap(){
        nil = new node(0 , -1);
        nil->left = nil->right = nil;
        nil->nr = nil->rev = 0;
        rad=nil;
    }

    void insert(int poz , int val ){
        rad = insert(rad,poz,val,rand());
    }
    /*
    void erase(int poz){
        rad=erase(rad,poz);
    }

    int find(int val){
        return find(rad,val);
    }

    void reverse(int st,int dr){
        pairnode a = split(rad , st-1);
        pairnode b = split(a.right , dr-st+1);
        b.left->rev ^= 1;
        rad = merge(a.left ,b.left);
        rad = merge(rad,b.right);
    }
    */
    vector<int> getvector(){
        q.clear();
        dfs(rad);
        return q;
    }

 private:
    struct node{
        int val ,prior  , nr;
        char rev;
        node *left, *right;

        node(int v,int p)
            : val(v) , prior(p){}

        node(node *l,node *r,int &v,int &p,char rc)
            : val(v) , prior(p) , rev(rc) , left(l) , right(r) {
            update(1);
        }

        void update(int tip){
            if( tip ) nr = left->nr + right->nr +1;
            if( rev ) {
                rev = false;
                swap(left,right);
                left->rev  ^= 1;
                right->rev ^= 1;
            }
        }
    };
    vector<int> q;
    node *nil , *rad;
    struct pairnode{
        node *left,*right;
        pairnode( node *l, node *r) : left(l) , right(r) {}
    };


    node* insert( node *nod , int poz ,int val ,int prior ){
        nod->update(0);
        if( nod->prior < prior){
            pairnode a = split( nod , poz );
            return new node(a.left , a.right , val , prior , 0 );
        }
        if( poz <= nod->left->nr )
            nod->left = insert(nod->left , poz, val , prior);
        else
            nod->right= insert(nod->right, poz - nod->left->nr -1, val , prior);
        nod->update(1);
        return nod;
    }

    pairnode split(node *nod,int poz){
        nod->update(0);
        if( nod == nil ) return pairnode(nil,nil);
        if( poz <= nod->left->nr ){
            pairnode a = split( nod->left , poz );
            nod->left = a.right;
            nod->update(1);
            return pairnode(a.left, nod);
        }else{
            pairnode a = split( nod->right, poz - nod->left->nr -1 );
            nod->right = a.left;
            nod->update(1);
            return pairnode(nod,a.right);
        }
    } /*
    node *erase( node *nod , int poz ){
        nod->update(0);
        if( poz == nod->left->nr +1 ){
            node *a=merge(nod->left ,nod->right );
            delete nod;
            return a;
        }
     if( poz <= nod->left->nr )
        nod->left = erase(nod->left , poz);
     else
        nod->right = erase(nod->right, poz - nod->left->nr -1);
     nod->update(1);
     return nod;

    }

    node *merge(node *left, node *right){
        left ->update(0);
        right->update(0);
        if(left==nil && right==nil) return nil;
        if(left->prior >right->prior){
            left->right = merge( left->right, right );
            left->update(1);
            return left;
        }
        else{
            right->left=merge(left,right->left);
            right->update(1);
            return right;
        }
    }
    int find(node *nod ,int poz){
        nod->update(0);
        if( poz == nod->left->nr +1 )
            return nod->val;
        if( poz <= nod->left->nr    )
            return find(nod->left,poz);
        return find(nod->right, poz - nod->left->nr -1 );
    }
    */
    void dfs(node *nod){
        if(nod==nil)
            return;
        nod->update(0);
        dfs(nod->left);
        q.push_back(nod->val);
        dfs(nod->right);
        }
};
treap v;

int main()
{



    freopen("schi.in" , "r" , stdin);
    freopen("schi.out", "w" , stdout);

    scanf("%d",&m);
    srand(time(0));
    for(int i=1;i<=m;++i){
        scanf("%d",&x);
        v.insert(x-1,i);
    }

    vector<int> sol = v.getvector();
    for_each( begin(sol) , end(sol) , [](int it){ cout << it <<'\n'; }  ) ;


    return 0;
}