# include <algorithm>
# include <cstdio>
# include <vector>
using namespace std ;

const char *FIN = "algsort.in", *FOU = "algsort.out" ;

namespace util {
#define NIL -1
#define MAX 8
#pragma region template <class T> class DArray
	template <class T> class DArray {
		T* col;
		int lun, maxC;
	public:
#pragma region DArray<T> :: Iterator
		class Iterator {
		protected:
			int current;
			DArray* list;
		public:
			Iterator(int position, const DArray* list): current(position) {
				this->list = const_cast< DArray* >(list);
			}
			virtual Iterator& operator++() {
				++this->current;
				return *this;
			}
			virtual Iterator operator++(int) {
				Iterator tmp = *this;
				++*this;
				return tmp;
			}
			virtual Iterator& operator--() {
				--this->current;
				return *this;
			}
			virtual Iterator operator--(int) {
				Iterator tmp = *this;
				--*this;
				return tmp;
			}
			T& operator*() const {
				return list->col[current];
			}
			T* operator->() {
				return &list->col[current];
			}
			bool operator ==(const Iterator& rhs) {
				return current == rhs.current;
			}
			bool operator !=(const Iterator& rhs) {
				return current != rhs.current;
			}
			Iterator operator +(const int n) {
				Iterator tmp = *this;
				tmp.current += n;
				return tmp;
			}
			void operator +=(const int n) {
				this->current += n;
			}
			Iterator operator -(const int n) {
				Iterator tmp = *this;
				tmp.current -= n;
				return tmp;
			}
			int operator -(const Iterator& rhs) {
				return this->current - rhs.current;
			}
			bool operator >(const Iterator& rhs) {
				return (this->current > rhs.current);
			}
			bool operator >=(const Iterator& rhs) {
				return (this->current >= rhs.current);
			}
			bool operator <(const Iterator& rhs) {
				return (this->current < rhs.current);
			}
			bool operator <=(const Iterator& rhs) {
				return (this->current <= rhs.current);
			}
		};
#pragma endregion
		DArray() :
			lun(0), maxC(MAX) {
			col = new T[MAX];
		}
		DArray(const DArray& da) {
			lun = da.lun;
			maxC = da.maxC;
			col = new T[maxC];
			for (int i = 0; i < lun; ++i)
				col[i] = da.col[i];
		}
		DArray& operator =(DArray da) {
			DArray::swap(*this, da);
			return *this;
		}
		bool operator ==(const DArray& da) const {
			if (lun != da.lun) return 0;
			for (int i = 0; i < lun; ++i)
				if (col[i] != da.col[i]) return 0;
			return 1;
		}
		virtual ~DArray() {
			delete[] col;
		}
		int size() const {
			return lun;
		}
		T& operator[](const int k) {
			return col[k];
		}
		const T& operator[](const int k) const {
			return col[k];
		}
		void PushBack(const T& e) {
			if (lun == maxC) resize();
			col[lun++] = e;
		}
		void remove(const int poz) {
			for (int i = poz; i < lun; ++i)
				col[i] = col[i + 1];
			lun -= 1;
		}
		Iterator Begin() const {
			Iterator it(0, this);
			return it;
		}
		Iterator End() const {
			Iterator it(lun, this);
			return it;
		}
	private:
		static void swap(DArray& da1, DArray& da2) {
			std::swap(da1.lun, da2.lun);
			std::swap(da1.maxC, da2.maxC);
			std::swap(da1.col, da2.col);
		}
		void resize() {
			T* tmp = new T[maxC <<= 1];
			for (int i = 0; i < lun; ++i)
				tmp[i] = col[i];
			delete[] col;
			col = tmp;
		}
	};
#pragma endregion

} /* namespace darray */

using namespace util;

DArray <int> V ;
int N ;

template <class Iter>
inline Iter SelectPivot(Iter begin, Iter end) {
	begin += (end - begin) / 2;
	return begin;
}

template <class Iter, class Cmp>
void QuickSort(Iter begin, Iter end, Cmp less) {
	Iter left = begin;
	Iter right = end;
	--right;
	if (left >= right) return;
	Iter pivot = SelectPivot(left, right);
	auto val = *pivot;

	//std::swap(*pivot, *right);

	//Iter pivot_position = left;
	while (left <= right) {
		for (; less(*left, val); ++left);
		for (; less(val, *right); --right);
		if (left <= right) {
			std::swap(*left, *right);
			++left, --right;
		}
	}

	QuickSort(begin, ++right, less);
	QuickSort(left, end, less);
}

template <class It, class Cmp>
inline void Sort(It First, It Last, Cmp FCmp) {
    QuickSort(First, Last, FCmp);
}

int main ( void ) {
    freopen ( FIN, "r", stdin ) ;

    scanf ( "%d", &N ) ;
    for ( int i = 0, x; i < N; ++i ) {
        scanf ( "%d", &x ) ;
        V.PushBack ( x ) ;
    }

    Sort(V.Begin(), V.End(), [](const int a, const int b) {
        return a < b;
    });

    freopen ( FOU, "w", stdout ) ;
    for ( int i = 0; i < N; ++i ) {
        printf ( "%d ", V[i] ) ;
    }
}