#include <fstream>
#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>

using namespace std;

typedef unsigned int uint32;

template<typename T>
class QSortParitionPredicate
{
public:
    QSortParitionPredicate(const T& v) :
        val(v)
    {}
    
    bool operator () (const T& elem) const
    {
        return elem < val;
    }

private:
    T val;
};

template <class BidirectionalIterator, class Predicate>
BidirectionalIterator do_partition(BidirectionalIterator start,
                                   BidirectionalIterator end, Predicate& pred)
{
    BidirectionalIterator partIndex = partition(start, end, pred);
        
    if (*partIndex > *(partIndex+1))
    {
        swap(*partIndex, *(partIndex+1));
    }
    
    return partIndex;
}

template <class Iter>
void quicksort(Iter start, Iter end)
{
    if (std::distance(start, end) > 0)
    {
        Iter pivot = start + (end - start)/2;
        QSortParitionPredicate<uint32> predQS(*pivot);
        
        Iter partIndex = do_partition(start, end, predQS);

        quicksort(start, partIndex);
        quicksort(partIndex+1, end);
    }
}

int main()
{
    int n;
    vector<uint32> vec;
    fstream fin("algsort.in", fstream::in);
    fstream fout("algsort.out", fstream::out);
    
    fin >> n;
    //cout << n << endl;
    
    vec.reserve(n);
    
    istream_iterator<uint32> inIt(fin);
    istream_iterator<uint32> eofIt;
    
    copy(inIt, eofIt, back_inserter(vec));
    
    /*for (int i=0; i<n; ++i)
    {
        //fin >> vec[i];
        cout << vec[i] << " ";
    }
    cout << endl;*/
    
    quicksort(vec.begin(), vec.end());
    
    ostream_iterator<uint32> outIt(fout, " ");
    copy(vec.begin(), vec.end(), outIt);
    
    //cout << endl;

    return 0;
}