#pragma GCC optimize("O2")

#include <iostream>
#include <fstream>
#include <cstring>

std::ifstream in(static_cast<const char*>("algsort.in"));
std::ofstream out(static_cast<const char*>("algsort.out"));

constexpr std::size_t mod = static_cast<std::size_t>(1ull << 32);
constexpr std::size_t mul = static_cast<std::size_t>(1664525);
constexpr std::size_t inc = static_cast<std::size_t>(1013904223);
std::size_t stt = 0;

static inline std::size_t _int() {
    return (stt = (mul * stt + inc) % mod);
}

constexpr std::size_t nmax = 500005;

std::size_t n, v[nmax];

static inline void interclasare(const std::size_t& s, const std::size_t& m, const std::size_t& d) {
    const std::size_t as = m - s + 1, bs = d - m;
    std::size_t * a = new std::size_t[as];
    std::size_t * b = new std::size_t[bs];
    std::memcpy(static_cast<void*>(a), static_cast<void*>(v + s), as * sizeof(std::size_t));
    std::memcpy(static_cast<void*>(b), static_cast<void*>(v + m + 1), bs * sizeof(std::size_t));
    std::size_t i, j, k;
    for(i = 0, j = 0, k = s; i < as && j < bs; ) {
        if(a[i] <= b[j]) {
            v[k++] = a[i++];
        } else {
            v[k++] = b[j++];
        }
    }
    if(i < as) {
        std::memcpy(static_cast<void*>(v + k), static_cast<void*>(a + i), (as - i) * sizeof(std::size_t));
        k += (as - i);
    }
    if(j < bs) {
        std::memcpy(static_cast<void*>(v + k), static_cast<void*>(b + j), (bs - j) * sizeof(std::size_t));
        k += (bs - j);
    }
    delete[] a;
    delete[] b;
}

static inline void sort(const std::size_t& s, const std::size_t& d) {
    if(s >= d) return;

    const std::size_t m = s + ((d - s) >> 1);
    sort(s, m);
    sort(m + 1, d);
    interclasare(s, m, d);
}

int main(void) {
    std::ios::sync_with_stdio(false);
    in.tie(nullptr);
    out.tie(nullptr);

    in >> n;
    for(std::size_t i = 1; i <= n; ++i) in >> v[i];
    sort(1, n);
    for(std::size_t i = 1; i <= n; ++i) out << v[i] << ' ';

    in.close();
    out.close();
    return 0;
}