#include <fstream>
#include <algorithm>
#include <math.h>
#include <assert.h>

inline void print(int n) {
	char snum[65];
	int i = 0;
	do {
		snum[i++] = n % 10 + '0';
		n /= 10;
	} while (n);

	--i;

	while (i >= 0) {
		putchar(snum[i--]);
	}

	putchar(' ');
}

inline int next_int() {
	int n = 0;
	char c = getchar_unlocked();
	
	while (!('0' <= c && c <= '9')) {
		c = getchar_unlocked();
	}
	
	while ('0' <= c && c <= '9') {
		n = n * 10 + c - '0';
		c = getchar_unlocked();
	}

	return n;
}

inline void swap(int *a, int *b) {
	int *temp = std::move(a);
	a = std::move(b);
	b = std::move(temp);
}

inline void insertion_sort(int v[], int *begin, int *end) {
	int left = begin - v;
	int right = end - v;

	for (int i = left + 1; i <= right ; ++i) {
		int element = v[i];
		int j = i - 1;

		while ( j >= left && v[j] > element) {
			v[j + 1] = v[j];
			--j;
		}

		v[j + 1] = element;
	}

	return;
}

inline int partition(int v[], int left, int right) {	
	int pos = random() % (right - left + 1) + left;
	int pivot = v[pos], i, j;
	
	for (i = left, j = right; ;) {
		for (; v[i] < pivot; ++i);
		for (; v[j] > pivot ; --j);
	
		if (i < j) {
			std::swap(v[i++], v[j--]);
		} else {
			return j;
		}
	}
}
	
 
	
inline void quicksort(int v[], int left, int right) {
	if (left >= right) {
		return;
	}
	
	int mid = partition(v, left, right);
	quicksort(v, left, mid);
	quicksort(v, mid + 1, right);
}
	
 
	
inline void intro_sort_utils(int v[], int *begin, int *end, int max_depth, int n) {
	int size = end - begin;
	
	if (size < 16) {
		insertion_sort(v, begin, end);
		return;
	}

	if (max_depth == 0) {
		std::make_heap(begin, end + 1);
		std::sort_heap(begin, end + 1);
		return;
	}
	
	quicksort(v, 0, n - 1);
	return;
}
	
 
	
inline void intro_sort(int v[], int *begin, int *end, int n) {
	int max_depth = 2 * log(end - begin);
	intro_sort_utils(v, begin, end, max_depth, n);
	return;
}

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

	assert(1 <= n && n <= 500000);
	int v[n];

	for (int i = 0 ; i < n ; ++i) {
		v[i] = next_int();
	}

	std::random_shuffle(v, v + n);
	intro_sort(v, v, v + n - 1, n);

	for (int i = 0 ; i < n ; ++i) {
		print(v[i]);
	}

	printf("\n");
	return 0;
}