#include <fstream>
#include <iostream>
#include <vector>
#include <ctime>


/**
 * MERGESORT
 */
void merge(std::vector<int> &aux, std::vector<int> &v, int lo, int mid, int hi)
{
    for (int k = lo; k <= hi; ++k)
        aux[k] = v[k];

    int i = lo, j = mid + 1;
    for (int k = lo; k <= hi; ++k) {
        if (i > mid)
            v[k] = aux[j++];
        else if (j > hi)
            v[k] = aux[i++];
        else if (aux[i] < aux[j])
            v[k] = aux[i++];
        else
            v[k] = aux[j++];
    }
}

void mergesort(std::vector<int> &aux, std::vector<int> &v, int lo, int hi)
{
    if (lo >= hi)
        return;

    int mid = lo + (hi - lo)/2;
    mergesort(aux, v, lo, mid);
    mergesort(aux, v, mid + 1, hi);
    merge(aux, v, lo, mid, hi);
}

void mergesort(std::vector<int> &v)
{
    std::vector<int> aux(v.size());
    mergesort(aux, v, 0, v.size() - 1);
}


/**
 * QUICKSORT
 */
void random_shuffle(std::vector<int> &v)
{
    srand(time(NULL));
    for (auto i = 0ul; i < v.size(); ++i) {
        int r = rand() % (i + 1);
        std::swap(v[i], v[r]);
    }
}

void quicksort(std::vector<int> &v, int lo, int hi)
{
    if (hi <= lo)
        return;

    int pivot = v[lo];
    int lt = lo, gt = hi;
    int i = lo;

    while (i <= gt) {
        if (v[i] < pivot)
            std::swap(v[lt++], v[i++]);
        else if (v[i] > pivot)
            std::swap(v[i], v[gt--]);
        else
            ++i;
    }

    quicksort(v, lo, lt - 1);
    quicksort(v, gt + 1, hi);
}

void quicksort(std::vector<int> &v)
{
    random_shuffle(v);
    quicksort(v, 0, v.size() - 1);
}


/**
 * HEAPSORT
 */
void sink(std::vector<int> &v, int k, int dim)
{
    while (2*k < dim) {
        auto son = 2 * k;
        if (son + 1 < dim && v[son] < v[son + 1])
            ++son;

        if (v[k] > v[son])
            break;

        std::swap(v[k], v[son]);
        k = son;
    }
}

void swim(std::vector<int> &v, int k)
{
    while (k > 1 && v[k] > v[k/2]) {
        std::swap(v[k], v[k/2]);
        k /= 2;
    }
}

void heapsort(std::vector<int> &v)
{
    for (auto i = v.size() / 2; i >= 1; --i)
        sink(v, i, v.size());

    for (auto i = v.size() - 1; i >= 1; --i) {
        std::swap(v[i], v[1]);
        sink(v, 1, i);
    }
}

void sort(std::vector<int> &v)
{
    /* heapsort(v); */
    /* quicksort(v); */
    mergesort(v);
}

int main()
{
    std::ifstream fin("algsort.in");
    std::ofstream fout("algsort.out");

    int N;
    fin >> N;

    std::vector<int> v(N);
    for (auto it = v.begin(); it != v.end(); ++it)
        fin >> *it;

    sort(v);
    for (auto it = v.cbegin(); it != v.cend(); ++it)
        fout << *it << " ";

    return 0;
}