#include <iostream>
#include <fstream>
#include <cstring>
#include <vector>
#include <algorithm>
#include <queue>

using namespace std;
ifstream in("algsort.in");
ofstream out("algsort.out");

#define ll long long
#define ull unsigned long long
#define pb push_back
#define mp make_pair
const int NMax = 1e7 + 5;
const int inf = 1e9 + 5;

// sortare prin selectarea maximului la fiecare pas prin smenul lui Batog;

int N,root;
int v[NMax],sorted[NMax],batog[NMax];
// root - o aproximare pentru sqrt(N);
// v - vectorul initial in care se taie treptat elemente;
// sorted - vector in care se pun in ordine elementele;
// batog[i] - reprezinta pozitia elementului maxim din intervalul [(i-1)*root+1,root*i];

void update(int,int);
// update(int i,int val) - schimba v[i] in val,
// dar modifica si informatiile asociate acestuia din vectorul batog;
int query(int,int);
// query(a,b) - returneaza pozitia elementului maxim din intervalul [a,b];

int main() {
    in>>N;

    root = 1;
    for (;root*root <= N;++root) ;
    --root;

    for (int i=1;i <= N;++i) {
        in>>v[i];

        // initializare a vectorului batog;
        // idx - reprezinta numarul de ordine a bucatelei de sqrt(N) in care se afla elementul cu pozitia i;
        int idx = (i-1) / root + 1;
        if (v[batog[idx]] < v[i]) {
            batog[idx] = i;
        }
    }

    for (int c=N;c > 0;--c) {
        int idx = query(1,N); // se scoate maximul;
        sorted[c] = v[idx]; // se pune in vectorul final;
        update(idx,-1); // se taie din vectorul initial;
    }

    for (int i=1;i <= N;++i) {
        out<<sorted[i]<<' ';
    }

    in.close();out.close();
    return 0;
}

void update(int i,int val) {
    int idx = (i-1)/root + 1,
        st = (idx-1)*root + 1,
        dr = idx*root;

    // batog[idx] - pozitia maximului din intervalul [st,dr];
    batog[idx] = 0;
    v[i] = val;
    for (int j=st;j <= dr;++j) {

        if (v[batog[idx]] < v[j]) {
            batog[idx] = j;
        }
    }
}

int query(int a,int b) {
    int ans = 0;

    // se parcurg elementele de la stanga bucatelelor de sqrt(N) cuprinse in intregime;
    int j = a;
    while ((j-1) % root != 0 && j <= b) {
        if (v[ans] < v[j]) {
            ans = j;
        }

        ++j;
    }

    // se parcurg bucatile de sqrt(N) cuprinse in intregime;
    while (j+root-1 <= b) {
        int idx = (j-1)/root + 1;
        if (v[ans] < v[ batog[idx] ]) {
            ans = batog[idx];
        }

        j += root;
    }

    // se parcurg elementele de la dreapta bucatelelor de sqrt(N) cuprinse in intregime;
   while (j <= b) {
        if (v[ans] < v[j]) {
            ans = j;
        }

        ++j;
   }

   return ans;
}