# include <fstream>
# define dim 500000
using namespace std;

int v[dim],nr_elem;

ifstream in("algsort.in");
ofstream out("algsort.out");

void swapf( int &x , int &y )
{
    int aux=x;
    x = y;
    y = aux;
}

void siftdown( int a[] , int start , int end )
{
    // end limita heap-ului
    int root = start,child,swap;
    // root ( radacina ) == parinte

    while( root*2+1 <= end )
    // cat timp parintele are cel putin un copil
    {
         child = root*2+1; // arata care este copilul din stanga
         swap = root;
         // tine evidenta copilul cu care facem interschimbarea

         if( a[swap] < a[child] ) // vedem daca copilul e mai mic dacat parintele
            swap = child;

        // verifica daca exista copilul din dreapta , si daca este mai mare decat elementul curent
        if( child+1 <= end && a[swap] < a[child+1] )
            swap = child+1;

        // verificam daca e necesara interschimbarea
        if( swap != root )
        {
            swapf(a[root],a[swap]);
            root = swap; // repetam pasii
        }
        else
            return;
    }
}

void heapify ( int a[] , int n )
{
    int start = (n-2)/2; // lui start i se atribuie ultimul parinte

    while( start >= 0 )
    {
        siftdown(a,start,n-1);
        --start;
    }
    // am creat heap-ul
}

void heapSort( int a[] , int n )
{
    heapify(a,n);

    int end = n-1;

    while( end > 0 )
    {
        // schimba valoarea maxima cu ultimul element al heap-ului
        swap(a[end],a[0]);
        --end;
        // re-aranjeaza heap-ul
        siftdown(a,0,end);
    }
}

void citire()
{
    in >> nr_elem;
    for( int i = 0 ; i < nr_elem ; ++i )
        in >> v[i];
    in.close();
}

void tipar()
{
    for( int i = 0 ; i < nr_elem ; ++i )
        out << v[i] << ' ';
    out.close();
}

int main()
{
    citire();
    heapSort(v,nr_elem);
    tipar();
    return 0;
}