#include <iostream>
#include <fstream>
#include <vector>
using namespace std;
ifstream fin("algsort.in");
ofstream fout("algsort.out");

class Sorter {
public:
    virtual vector<int> sort(const vector<int>& numbers) const = 0;

    virtual ~Sorter() = default;
};

class MergeSorter : public Sorter {
public:
    vector<int> sort(const vector<int>& numbers) const override {
        vector<int> sortedNumbers(numbers);
        sort(sortedNumbers, 0, (int)numbers.size() - 1);
        return sortedNumbers;
    }

private:
    void sort(vector<int>& numbers, int leftIndex, int rightIndex) const {
        // cout << leftIndex << " " << rightIndex << "\n";
        if (leftIndex >= rightIndex) {
            return;
        }

        int middleIndex = (leftIndex + rightIndex) / 2;
        sort(numbers, leftIndex, middleIndex);
        sort(numbers, middleIndex + 1, rightIndex);
        merge(numbers, leftIndex, rightIndex);
    }

    void merge(vector<int>& numbers, int leftIndex, int rightIndex) const {
        if (leftIndex >= rightIndex) {
            return;
        }

        int middleIndex = (leftIndex + rightIndex) / 2;

        vector<int> mergedValues(rightIndex - leftIndex + 1);
        int mergedValuesIndex = 0;

        int currentLeftHalfIndex = leftIndex;
        int currentRightHalfIndex = middleIndex + 1;
        while (currentLeftHalfIndex <= middleIndex && currentRightHalfIndex <= rightIndex) {
            if (numbers[currentLeftHalfIndex] <= numbers[currentRightHalfIndex]) {
                mergedValues[mergedValuesIndex++] = numbers[currentLeftHalfIndex++];
            } else {
                mergedValues[mergedValuesIndex++] = numbers[currentRightHalfIndex++];
            }
        }
        while (currentLeftHalfIndex <= middleIndex) {
            mergedValues[mergedValuesIndex++] = numbers[currentLeftHalfIndex++];
        }
        while (currentRightHalfIndex <= rightIndex) {
            mergedValues[mergedValuesIndex++] = numbers[currentRightHalfIndex++];
        }

        for (int i = leftIndex; i <= rightIndex; i++) {
            numbers[i] = mergedValues[i - leftIndex];
        }
    }
};

class QuickSorter : public Sorter {
public:
    vector<int> sort(const vector<int>& numbers) const override {

    }
};

void sortAndPrint(const vector<int>& numbers, const Sorter& sorter) {
    vector<int> sortedNumbers = sorter.sort(numbers);
    // cout << "printing with size " << sortedNumbers.size() << "\n";
    for (int number : sortedNumbers) {
        fout << number << " ";
    }
}

int main() {
    int n;
    fin >> n;
    vector<int> numbers(n);
    for (int i = 0; i < n; i++) {
        fin >> numbers[i];
    }

    sortAndPrint(numbers, MergeSorter());

    return 0;
}