#pragma GCC optimize("O2")

#include <cstdint>
#include <cstdio>

constexpr uint32_t mod = static_cast<uint32_t>((1ull << 32) - 1);
constexpr uint32_t mul = static_cast<uint32_t>(1664525);
constexpr uint32_t inc = static_cast<uint32_t>(1013904223);
uint32_t stt = 0;

static inline uint32_t _int() {
    return (stt = (mul * stt + inc) & mod);
}

constexpr uint32_t nmax = 500005;

uint32_t n, v[nmax];

static inline void isort(const uint32_t& s, const uint32_t& d) {
    for(uint32_t i = s + 1, j; i <= d; ++i) {
        const uint32_t x = v[i];
        for(j = i; j > s && v[j - 1] > x; --j) {
            v[j] = v[j - 1];
        }
        v[j] = x;
    }
}

static inline uint32_t partition(const uint32_t& s, const uint32_t& d) {
    const uint32_t& pivot = v[d];
    uint32_t i = s - 1, j;
    for(j = s; j < d; ++j) {
        if(v[j] < pivot) {
            ++i;
            const int& tmp = v[i];
            v[i] = v[j];
            v[j] = tmp;
        }
    }
    const int& tmp = v[i + 1];
    v[i + 1] = v[d];
    v[d] = tmp;
    return i + 1;
}

static inline void hsort(uint32_t s, uint32_t d) {
    for(; s < d; ) {
        if(d - s < 16) {
            isort(s, d);
            break;
        }

        const uint32_t pz = s + (_int() % (d - s));
        const int& tmp = v[pz];
        v[pz] = v[d];
        v[d] = tmp;
        const uint32_t& p = partition(s, d);

        if(p - s < d - p) {
            hsort(s, p - 1);
            s = p + 1;
        } else {
            hsort(p + 1, d);
            d = p - 1;
        }
    }
}

char buffer[4096] = {0}, obuffer[65536] = {0};
uint32_t poz = 0, opoz = 0;

static inline bool isdigit(const char& c) {
    return ('0' <= c && c <= '9');
}

__attribute__((always_inline)) static inline char& read_ch() {
    if(++poz == 4096) {
        poz = 0;
        fread(static_cast<void*>(buffer), 1, 4096, stdin);
    }

    return buffer[poz];
}

__attribute__((always_inline)) static inline void write_ch(const char& ch) {
    if(opoz == 65536) {
        fwrite(static_cast<void*>(obuffer), 1, 65536, stdout);
        opoz = 0;
        obuffer[opoz++] = ch;
    } else {
        obuffer[opoz++] = ch;
    }
}

__attribute__((always_inline)) static inline void parse(uint32_t& n) {
    char c;
    n = 0;
    while (!isdigit(c = read_ch()) && c != '-');
    uint32_t sgn = 1;
    if (c == '-') {
        n = 0;
        sgn = -1;
    } else {
        n = c - '0';
    }
    while (isdigit(c = read_ch())) {
        n = 10 * n + c - '0';
    }
    n *= sgn;
}

static void parseout(const uint32_t& n) {
    if (n <= 9) {
        write_ch(n + '0');
    } else {
        parseout(n / 10);
        write_ch(n % 10 + '0');
    }
}

int main(void) {
    freopen("algsort.in", "r", stdin);
    freopen("algsort.out", "w", stdout);

    poz = 4095;

    parse(n);
    for(uint32_t i = 1; i <= n; ++i) parse(v[i]);
    hsort(1, n);
    for(uint32_t i = 1; i <= n; ++i) {
        parseout(v[i]);
        write_ch(' ');
    }

    fwrite(static_cast<void*>(obuffer), 1, opoz, stdout);
    return 0;
}