#include <fstream>
#include <iostream>
#include <cstring>
using namespace std;

const int nil = 0x3f3f3f3f;

template<class Data, int cap, int T>
class Bsort{
    Data key[cap / (T - 1)][2 * T - 1];
    int son[cap / (T - 1)][2 * T], size[cap / (T - 1)];
    int root, newNode, stepSize;

    int find(Data* v, Data K, int N){
        if (K <= v[0])
            return 0;
        int ans = 0;
        for (int step = stepSize, aux = stepSize ; step ; step >>= 1, aux = ans ^ step)
            if (aux < N && v[aux] < K)
                ans = aux;
        return ans + 1;
    }

    void split(int node, int index){
        int st = son[node][index], dr = newNode++;
        for (int i = size[node] ; i > index ; i--){
            key[node][i] = key[node][i - 1];
            son[node][i + 1] = son[node][i];
        }
        key[node][index] = key[st][T - 1];
        son[node][index + 1] = dr;
        size[node]++;

        for (int i = 0 ; i < T - 1 ; i++){
            key[dr][i] = key[st][i + T];
            son[dr][i] = son[st][i + T];
        }

        son[dr][T - 1] = son[st][2 * T - 1];
        size[st] = size[dr] = T - 1;
    }

    void parcurgere( int node, void (*work)(Data) ){
        if ( son[node][0] == nil ){
            for (int i = 0 ; i < size[node] ; i++)
                work( key[node][i] );
            return;
        }
        for (int i = 0 ; i < size[node] ; i++){
            parcurgere(son[node][i], work);
            work(key[node][i]);
        }

        return parcurgere( son[node][ size[node] ], work );
    }

public:
    Bsort(){
        newNode = 0;
        memset(son, nil, sizeof(son));
        memset(size, 0, sizeof(size));
        root = newNode++;

        stepSize = 1;
        while (stepSize <= T)
            stepSize <<= 1;
    }

    void insert(Data K){
        int node = root, index;
        if ( 1 + size[node] == (T << 1) ){
            node = newNode++;
            son[node][0] = root;
            root = node;
            split(root, 0);
        }
        while ( son[node][0] != nil ){
            index = find(key[node], K, size[node]);
            if ( 1 + size[ son[node][index] ] == (T << 1) ){
                split(node, index);
                if ( key[node][index] < K )
                    index++;
            }
            node = son[node][index];
        }

        index = size[node];
        for (index = size[node] ; index && K < key[node][index - 1] ; index--)
            key[node][index] = key[node][index - 1];
        key[node][index] = K;
        size[node]++;
    }

    void parcurgere( void (*work)(Data) ){
        return parcurgere(root, work);
    }
};

Bsort<int, 500000, 100> B;
int prev = -1;

ifstream in("algsort.in");
ofstream out("algsort.out");

void print(int x){
    //if (x < prev) cout << "FAULT";
    out << x << " ";
    //prev = x;
}

int main(){
    int n, x;
    in >> n;
    while (n--){
        in >> x;
        B.insert(x);
/*
        B.parcurgere(print);
        out << "\n";
*/
    }
    B.parcurgere(print);
    return 0;
}