#include <iostream>
#include <iomanip>
#include <fstream>

#include <algorithm>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>

#if __cplusplus > 199711L
#include <unordered_map>
#include <unordered_set>
#endif

#include <cstdio>
#include <ctime>
#include <cmath>
#include <cstring>
#include <cstdlib>

using namespace std;

typedef long long int64;

const int BUFFER_SIZE = 1 << 21;

class InputReader {
    public:
        InputReader() {}
        InputReader(const char* filename) {
            file = fopen(filename, "r");
            cursor = 0;
            fread(buffer, BUFFER_SIZE, 1, file);
        }
        inline InputReader & operator >> (int &n) {
            n = 0;
            sign = 1;
            while(!isdigit(buffer[cursor])) {
                if (buffer[cursor] == '-') sign = -1;
                advance();
            }
            while(isdigit(buffer[cursor])) {
                n = n * 10 + buffer[cursor] - '0';
                advance();
            }
            n *= sign;
            return *this;
        }
        inline void close() {
            fclose(file);
        }
    private:
        int cursor, sign;
        char buffer[BUFFER_SIZE];
        FILE* file;
        inline void advance() {
            ++cursor;
            if(cursor == BUFFER_SIZE) {
                cursor = 0;
                fread(buffer, BUFFER_SIZE, 1, file);
            }
        }
};

InputReader in("algsort.in");
ofstream out("algsort.out");

const int NMAX = 500010;

int N;
int V[NMAX];

int Partition(int left, int right) {
    for (int i = left; i < right; ++i)
        if (V[i] < V[right])
            swap(V[i], V[left++]);

    swap(V[right], V[left]);
    return left;
}

void QuickSort(int left, int right) {
    if (left >= right) return;

    int Part = Partition(left, right);
    QuickSort(left, Part);
    QuickSort(Part + 1, right);
}

int main() {
    int i;
    srand(time(NULL));

    in >> N;
    for (i = 1; i <= N; ++i) in >> V[i];

    //QuickSort(1, N);
    sort(V + 1, V + N + 1);
    for (i = 1; i <= N; ++i) out << V[i] << ' ';
    out << '\n';

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