#include <iostream>
#include <fstream>

using namespace std;

ifstream fin("26:7:2023.in");
ofstream fout("26:7:2023.out");
/*
    
    comanda "-insert-"

    6
    4 1 7 5 1 3

             4[1]
             / \
        1[2]      7[3]
       /    \     / 
    5[4]   1[5]   3[6]

    nodul de pe pozitia i
           tata : in pozitia i/2
     fiu_stanga : in pozitia 2*i
    fiu dreapta : in pozitia 2*i+1

    Heap(max_heap)
     - arbore binar
     - in fiecare nod am valori
     - conditia de MAX_HEAP : valorile din tata sunt >= valorile din fii


          NOD(X)
    FS(S)          FD(D)

    FS = heap
    FD = heap 
    NOD = heap???
        DA, daca X >= S si  D
        Nu, daca X < S sau X < D
    ALEG CEA MAI MARE VALOARE DINTRE S SI D
    SCIMB X CU ACEA VALOARE !!!
         EXEMPLU X<S DAR S>=D

            NOD(S)
      FS(X)     FD(D)

    acum S>=D
        S>=X deci in NOD am respectat conditia de heap !!!
        DAR !!! in fiu stanga nu stiu daca mai este respectata !!!
        REFAC STRUCTURA DAR INCEP DIN POZITIA FS !!!

    REPARA_HEAP is pozitia NOD
        vezi DACA AI FII
            DACA NU -> OK 
            DACA DA
                VAZI DACA AI AMBII FII
                    DACA NU FIUL PREFERAT ESTE CEL DIN STANGA
                    DACA DA ALEGE FIUL PREFERAT PE CEL CARE ARE VALOAREA MAI MARE
                        VEZI DACA LA FIUL PREFERAT AI VALOARE MAI MARE
                            DACA NU - OK
                            DACA DA
                                SCHIMBA VALOARE CU CEA DIN FIUL PREFERAT
                                REPARA_HEAP in pozitia FIU_PREFERAT

            4[1]
             / \
        1[2]      7[3]
       /    \     / 
    5[4]   1[5]   3[6]

             4[1]
             / \
        5[2]      7[3]
       /    \     / 
    514]   1[5]   3[6]

             7[1]
             / \
        5[2]      4[3]
       /    \     / 
    514]   1[5]   3[6]




             4[3]
             / \
        5[2]      4[3]
       /    \     / 
    514]   1[5]  7[6]


             3[3]
             / \
        5[2]      4[3]
       /    \     
    514]   1[5]  

             3[3]   ?????????????????????
             / \
        5[2]      4[3]
       /    \     
    5[4]   1[5]  

        1 2 3 4 5 6 
        1 1 3 4 5 7

*/

const int N = 500010;
int n,a[N];

int heapDown(int nod, int lgHeap)
{
    int fiu=2*nod;          //aleg fiul preferat ca fiind cel din stanga - cel din dreapta este la poz fiu+1
    if(fiu>lgHeap) return 0;  //nod este o frunza? daca da e ok !!!
    if(fiu<lgHeap)          // nod are doi fii !!!
    {
        if(a[fiu+1]>a[fiu])  //daca fiu dreapta are valoare mai mare
        {
            fiu++;          //alege fiu preferat = fiu dreapta
        }
    }
    if(a[fiu]>a[nod])
    {
        swap(a[fiu],a[nod]);
        heapDown(fiu, lgHeap);
    }
}

int main()
    {
    ///citire
    fin>>n;
    for(int i=1; i<=n; i++)
    {
        fin>>a[i];
    }

    //da sirul structura de max_heap
    for(int i=n/2; i>=1; i--)
    {
        heapDown(i,n);
    }

    for(int i=n; i>1; i--)
    {
        swap(a[i], a[1]);
        heapDown(1, i-1);
    }

    for(int i=1; i<=n; i++)
    {
        fout<<a[i]<<" ";
    }

    return 0;
}