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

template<const size_t _size>
class IntReader {
public:
    IntReader(std::istream *os) : _os(os) {
        _pointer = 0;
        _os->read(_buffer, _size);
    }
    ~IntReader() {}

    IntReader& operator >> (short &rhs) {
        rhs = next_int<short int>();
        return *(this);
    }

    IntReader& operator >> (int &rhs) {
        rhs = next_int<int>();
        return *(this);
    }

    IntReader& operator >> (long long int &rhs) {
        rhs = next_int<long long int>();
        return *(this);
    }

private:
    template<typename IntType>
    IntType next_int() {
        IntType ret = 0;
        bool negative = false;

        while ((current() < '0' || current() > '9') && current() != '-')
            next_position();
        if (current() == '-') {
            negative = true;
            next_position();
        }
        while ('0' <= current() && current() <= '9') {
            ret = ret * 10 + current() - '0';
            next_position();
        }
        return (negative) ? -ret : ret;
    }

    char current() const {
        return _buffer[_pointer];
    }

    void next_position() {
        if (++_pointer == _size) {
            _os->read(_buffer, _size);
            _pointer = 0;
        }
    }


    size_t _pointer;
    char _buffer[_size];
    std::istream *_os;
};


const int nmax = 500005;
int elements[nmax];
int aux[nmax];
int n;


void read() {
    std::ifstream aux_in("algsort.in");
    IntReader<524288> in(&aux_in);

    in >> n;
    for (int i = 1; i <= n; ++i)
        in >> elements[i];
}

void merge_sort(int l, int r) {
    if (l == r) return;
    else if (r - l == 1) {
        if (elements[l] > elements[r])
            std::swap(elements[l], elements[r]);
        return;
    }
    else {
        int m = (l + r) / 2;
        merge_sort(l, m);
        merge_sort(m + 1, r);
        for (int i = l, j = m + 1, k = l; i <= m || j <= r; ++k) {
            if (i > m || (j <= r && elements[j] < elements[i]))
                aux[k] = elements[j++];
            else
                aux[k] = elements[i++];
        }
        for (int i = l; i <= r; ++i)
            elements[i] = aux[i];
    }
}

void print() {
    std::ofstream out("algsort.out");
    for (int i = 1; i <= n; ++i)
        out << elements[i] << ' ';
}

int main() {
    read();
    merge_sort(1, n);
    print();

    return 0;
}