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

std::ifstream f("algsort.in");
std::ofstream g("algsort.out");

std::vector<int> v;

void read()
{
    int n, x;

    f >> n;
    for (int i = 0; i < n; i ++) {
        f >> x;
        v.push_back(x);
    }
}

void write()
{
    for (int i = 0; i < (int) v.size(); i ++) {
        g << v[i] << ' ';
    }
}

int partition(int first, int last)
{
    int i, j;
    int piv;

    piv = (rand() % (last - first + 1)) + first;
    std::swap(v[piv], v[first]);

    i = j = first + 1;

    while(j <= last) {
        if (v[j] < v[first]) {
            std::swap(v[i], v[j]);
            i ++;
        }
        j ++;
    }
    std::swap(v[i - 1], v[first]);

    return i - 1;
}

void quicksort(int first, int last)
{
    if (first >= last) {
        return;
    }

    int k = partition(first, last);

    quicksort(first, k - 1);
    quicksort(k + 1, last);
}

void merge(int first, int mid, int last) {
    std::vector<int> aux;

    int i = first, j = mid + 1;

    while (i <= mid && j <= last) {
        if (v[i] < v[j]) {
            aux.push_back(v[i ++]);
        }
        else {
            aux.push_back(v[j ++]);
        }
    }

    while (i <= mid) {
        aux.push_back(v[i ++]);
    }
    while (j <= last) {
        aux.push_back(v[j ++]);
    }

    for (int k = 0; k < (int) aux.size(); k ++) {
        v[first + k] = aux[k];
    }
}

void mergesort(int first, int last)
{
    if (first == last) {
        return;
    }

    int mid = (first + last) / 2;

    mergesort(first, mid);
    mergesort(mid + 1, last);

    merge(first, mid, last);
}

int main()
{
    read();
    mergesort(0, v.size() - 1);
    write();

    return 0;
}