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


/**
 * 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]);
    }
}

int partition(std::vector<int> &v, int lo, int hi)
{
    int i = lo, j = hi + 1;

    while (true) {
        while (v[lo] > v[++i])
            if (i == hi)
                break;

        while (v[lo] < v[--j])
            if (j == lo)
                break;

        if (i >= j)
            break;

        std::swap(v[i], v[j]);
    }

    std::swap(v[lo], v[j]);
    return j;
}

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

    int j = partition(v, lo, hi);
    quicksort(v, lo, j - 1);
    quicksort(v, j + 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);
}

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;
}