#include <iostream>
#include <fstream>
#include <vector>

using namespace std;
int N;
ofstream fout("algsort.out");

template <class T>
class PriorityQueue
{
    private: vector<T> Queuee;
             void shiftDown(int,int);
             void shiftUp(int,int);
             void Build_heap();
    public: PriorityQueue();
            PriorityQueue(vector<T>&);
            void push(T);
            void print();
            void HeapSort();
};

template <class T> PriorityQueue<T>::PriorityQueue() { }

template <class T> PriorityQueue<T>::PriorityQueue(vector <T>& v)
  {
      if(v.size()>0)
	  {Queuee=v;
       Build_heap();}
  }


template <class T> void PriorityQueue<T>::push(T val)
	{
		Queuee.push_back(val);
        shiftUp(0, Queuee.size() - 1);
	}

template <class T> void PriorityQueue<T>::print()
{
    int sizee=Queuee.size();
    if(sizee<1) {cout<<"Empty heap!"<<endl;return;}
    for (int i=0;i<sizee;i++)
        fout<<Queuee[i]<<" ";
}

template <class T> void PriorityQueue<T>::shiftUp(int first, int last)
{
    int child=last;
    while(child>first)
    {
        int parent=(child-1)/2;
        if(Queuee[child]>Queuee[parent])
        {
            T aux=Queuee[child];
            Queuee[child]=Queuee[parent];
            Queuee[parent]=aux;

            child = parent;
        }
        else break;
    }
}
template <class T> void PriorityQueue<T>::shiftDown(int first, int last)
{
    int root=first;
    while ((root*2)+1<=last)
    {
        int left=(root*2)+1;
        int right=left+1;
        int toswap=root;
        if(Queuee[toswap]<Queuee[left])
            toswap=left;
        if((right<=last) && (Queuee[toswap]<Queuee[right]))
            toswap=right;
        if (toswap!=root)
        {
            T aux=Queuee[root];
            Queuee[root]=Queuee[toswap];
            Queuee[toswap]=aux;

            root=toswap;
        }
        else break;
    }
}
template <class T> void PriorityQueue<T>::Build_heap()
{
    int sizee=Queuee.size();
    for (int i = (sizee-1)/2; i >=0; --i)
    {
        shiftDown(i, sizee-1);
    }
}

template <class T> void PriorityQueue<T>::HeapSort()
{
    int i;
    T temp;
    //build_heap();
    for (i=Queuee.size()-1;i>=1;i--)
    {
        temp=Queuee[0];
        Queuee[0]=Queuee[i];
        Queuee[i]=temp;
        shiftDown(0,i-1);

    }
}


int main()
{
    ifstream fin("algsort.in");
    int x;
    PriorityQueue<int>PQ;
    fin>>N;
    while(fin>>x)
        PQ.push(x);
    PQ.HeapSort();
    PQ.print();
    return 0;
}