#include <iostream>
#include <fstream>
#include <cmath>
#define minim first
#define position second
#define pii pair<unsigned int, int>
#define Next ++ pos == limit ? f.read(buffer, limit), pos = 0 : 0
#define ch buffer[pos]

using namespace std;

const int limit = 1024 * 1024;
int pos;
char buffer[limit];
const int NMax = 500010;
const unsigned int INF = 4000000000U;
int N;
unsigned int a[NMax];
int rad;
pii v[720];
int ans[NMax];
ifstream f("algsort.in");

void Read(unsigned int & x)
{
    for (; '0' > ch || ch > '9'; Next);
    for (x = 0; '0' <= ch && ch <= '9'; x = x * 10 + ch - '0', Next);
}

void Read(int & x)
{
    for (; '0' > ch || ch > '9'; Next);
    for (x = 0; '0' <= ch && ch <= '9'; x = x * 10 + ch - '0', Next);
}

void Read()
{
    f.read(buffer, limit);
    Read(N);
    for (int i = 1; i <= N; ++ i)
        Read(a[i]);
    f.close();
}

void Solve()
{
    rad = (int)sqrt(1.0 * N);
    int j = 0;
    for (int i = 1; i <= rad; ++ i)
    {
        unsigned int m = INF;
        int p;
        for (int pas = 1; pas <= rad; ++ pas)
        {
            ++ j;
            if (a[j] <= m)
            {
                m = a[j];
                p = j;
            }
        }
        v[i].minim = m;
        v[i].position = p;
    }
    if (rad * rad != N)
    {
        unsigned int m = INF;
        int p;
        for (++ j; j <= N; ++ j)
            if (a[j] <= m)
            {
                m = a[j];
                p = j;
            }
        v[rad + 1].minim = m;
        v[rad + 1].position = p;
    }
    for (int index = 1; index <= N; ++ index)
    {
        unsigned int m;
        int p;
        m = INF;
        for (int i = 1; i <= rad; ++ i)
            if (v[i].minim <= m)
            {
                m = v[i].minim;
                p = i;
            }
        if (rad * rad != N && v[rad + 1].minim <= m)
        {
            m = v[rad + 1].minim;
            p = rad + 1;
        }
        ans[index] = m;
        a[v[p].position] = INF;
        if (p == rad + 1)
        {
            unsigned int m = INF;
            int pp;
            for (int i = rad * rad + 1; i <= N; ++ i)
                if (a[i] <= m)
                {
                    m = a[i];
                    pp = i;
                }
            v[rad + 1].minim = m;
            v[rad + 1].position = pp;
        }
        else
        {
            unsigned int m = INF;
            int pp;
            for (int i = rad * (p - 1) + 1; i <= rad * p; ++ i)
                if (a[i] <= m)
                {
                    m = a[i];
                    pp = i;
                }
            v[p].minim = m;
            v[p].position = pp;
        }
    }
}

void Write()
{
    ofstream g ("algsort.out");
    for (int i = 1; i <= N; ++ i)
        g << ans[i] << " ";
    g << "\n";
    g.close();
}

int main()
{
    Read();
    Solve();
    Write();
    return 0;
}