# include <fstream>
# include <iostream>
# include <deque>
# include <assert.h>

using namespace std;

template <typename type>
class parv {
    public:
    int n, base;
    deque<type> * p;

    pair<int, int> index( int pos ) {
        assert( pos >= 0 && pos < n );

        int i, j, s;

        s = n / base;
        if ( pos <= ( ( n - 1 ) % base + 1 ) * ( s + 1 ) ) {
            i = pos / ( s + 1 );
            j = pos % ( s + 1 );
        } else {
            pos -= n % base;
        //cout << n << endl;
            i = pos / s;
            j = pos % s;
        }

        //cout << n << ' ' << i << ' ' << j << endl;

        return make_pair( i, j );
    }

    parv( int _base ) {
        base = _base;
        p = new deque<type>[base];
        n = 0;
    }

    type operator[]( int pos ) {
        assert( pos < n );

        pair<int, int> i = index( pos );

        return p[i.first][i.second];
    }

    void push( int pos, type val ) {
        assert( pos <= n );

        pair<int, int> k;
        if ( pos < n )
            k = index( pos );
        else {
            if ( pos <= base - 1 )
                k.first = pos;
            else
                k.first = base - 1;

            k.second = p[k.first].size();
        }

        int f, s;
        f = k.first;
        s = k.second;

        p[f].push_back( val );

        for ( int i = p[f].size() - 1; i > s; i -- )
            swap( p[f][i], p[f][i - 1] );

        while ( f > n % base ) {
            p[f - 1].push_back( p[f].front() );
            p[f].pop_front();

            f --;
        }

        while ( f < n % base ) {
            p[f + 1].push_front( p[f].back() );
            p[f].pop_back();

            f ++;
        }

        n ++;
    }

    int size() {
        return n;
    }
};

int main() {
    parv<int> f( 10 );

    ifstream fin( "schi.in" );
    ofstream fout( "schi.out" );

    int n, i, nr;

    fin >> n;

    for ( i = 1; i <= n; i ++ ) {
        fin >> nr;
        f.push( nr - 1, i );
    }

    for ( int j = 0; j < f.size(); j ++ )
        fout << f[j] << '\n';

    fin.close();
    fout.close();

    return 0;
}