#include <iostream>
#include <fstream>
#include <cstring>

using namespace std;

#define HeapCapacity 500005

class Heap
{
    public:

    int h[HeapCapacity];
    int NumberOfElements;

    Heap()
    {
        memset( h, 0, sizeof(h) );
        NumberOfElements = 0;
    }

    inline int Father( int i )   { return i/2;   }
    inline int LeftSon( int i )  { return 2*i;   }
    inline int RightSon( int i ) { return 2*i+1; }

    inline int maxim() { return h[1]; };

    void Sift( int N, int K )
    {
        int son;

        do
        {
            son = 0;

            if ( LeftSon(K) <= N )
            {
                son = LeftSon(K);

                if ( RightSon(K) <= N &&
                    h[RightSon(K)] > h[LeftSon(K)] )
                        son = RightSon(K);

                if ( h[son] <= h[K] )
                    son = 0;
            }

            if ( son )
            {
                swap( h[K], h[son] );
                K = son;
            }

        }while( son );
    }

    void Percolate( int K )
    {
        int key = h[K];

        while( (K > 1) && (key > h[Father(K)]) )
        {
            h[K] = h[Father(K)];
            K = Father(K);
        }

        h[K] = key;
    }

    void BuildHeap()
    {
        for ( int i = NumberOfElements/2; i > 0; i-- )
        {
            Sift(NumberOfElements, i);
        }
    }

    void Delete( int K )
    {
        h[K] = h[NumberOfElements];
        NumberOfElements--;

        if ( (K > 1) && (h[K] > h[Father(K)]) )
            Percolate(K);
        else
            Sift(NumberOfElements, K);
    }

    void Insert( int key )
    {
        h[ ++NumberOfElements ] = key;
        Percolate( NumberOfElements );
    }

    void HeapSort()
    {
        BuildHeap();

        for ( int i = NumberOfElements; i >= 2; i-- )
        {
            swap(h[1],h[i]);
            Sift( i-1, 1 );
        }
    }

    friend ofstream& operator << (ofstream &f, Heap H)
    {
        for ( int i = 1; i <= H.NumberOfElements; i++ )
            f << H.h[i] << " ";

        return f;
    }
};

int main()
{
    ifstream f("algsort.in");
    ofstream g("algsort.out");

    Heap H;

    int n, a, i;

    f >> n;

    for ( i = 1; i <= n; i++ )
    {
        f >> a;
        H.Insert(a);
    }

    H.HeapSort();

    g << H;

    return 0;
}