#include <fstream>
std::ifstream cin("algsort.in");
std::ofstream cout("algsort.out");
#define maxn 500050
int v[maxn],N;

// *****READ&OUT******
void afis(int v[],int n){
    for(int i=1;i<=n;i++)
        cout<<v[i]<<' ';
}
void citire(int v[],int &n){
    cin>>n;
    for(int i=1;i<=n;i++)
        cin>>v[i];
}
// *****READ&OUT******
/*
// *********QUICKSORTS****************
//DEI type
void quicksort(int v[],int st, int dr){
    if(st<dr){ //average 40 pct
        int i=st, aux;
        int rad=v[dr];
        for(int j=st;j<dr;j++)
            if(v[j]<rad){
                std::swap(v[i],v[j]);
                i+=1;
            }
        v[dr]=v[i];
        v[i]=rad;
        quicksort(v,st,i-1);
        quicksort(v,i+1,dr);
    }
}
void quicksort_medianOfThree(int v[],int st, int dr){
    if(st<dr){//best 40pct slightly better than ^
        int med=(st+dr)/2;
        if(v[st]>v[med])
            std::swap(v[st],v[med]);//most efficient
        if(v[st]>v[dr]) //swap really slows down algorithm
            std::swap(v[dr],v[st]);
        if(v[med]>v[dr])
            std::swap(v[dr],v[med]);
        int rad=v[med], i=st+1;
        std::swap(v[med],v[dr-1]);
        for(int j=st+1;j<dr-1;j++)
            if(v[j]<rad){
                std::swap(v[i],v[j]);
                i+=1;
            }
        std::swap(v[i],v[dr-1]);
        quicksort(v,st,i-1);
        quicksort(v,i+1,dr);
    }
}
void updatedquicksort(int v[],int st, int dr){
    if(st<dr){ //worst quicksort 0pct inefficient
        int i=st,j=dr-1,rad=v[dr],aux;
        for(;;){
            while(v[i]<rad) i++;
            while(v[j]>rad) j--;
            if(i<j){
                aux=v[i];
                v[i]=v[j];
                v[j]=aux;
            }
            else
                break;
        }
        aux=v[i];
        v[i]=v[dr];
        v[dr]=aux;
        updatedquicksort(v,st,i-1);
        updatedquicksort(v,i+1,dr);
    }
}
// *************END**QUICKSORTS*******
*/
/*
// ******MERGESORT**********gets 100pct
//DEI type
void mergexd(int v[],int l, int m, int r){
    int n1,n2,i,j,k; //merge sort gets 100pct
    n1=m-l+1; // the length of the left side till middle
    n2=r-m; //length of right side

    int la[n1],ra[n2]; //create the temporary arrays

    for(int i=0;i<n1;i++)
        la[i]=v[l+i]; //initialize left array
    for(int i=0;i<n2;i++)
        ra[i]=v[m+i+1]; //initialize right array
    i=0;j=0; //index of temporaries arrays
    k=l;//index of official array
    while(i<n1&&j<n2){
        if(la[i]<ra[j]){
            v[k]=la[i];
            i++;
        }else{
            v[k]=ra[j];
            j++;
        }
        k++;
    }
    while(i<n1){
        v[k]=la[i];
        i++;k++;
    }
    while(j<n2){
        v[k]=ra[j];
        j++;k++;
    }
}

void merge_sort(int v[],int l,int r){
    if(l<r){
        int m=(l+r)/2;
        merge_sort(v,l,m);
        merge_sort(v,m+1,r);

        mergexd(v,l,m,r);
    }
}
// ********END**MERGESORT************
*/

/*
// *******SHELLSORT**********
// Surprisingly it gets 60 pct, very close to 100
void shellsort(int v[],int n){
    for(int gap=n/2;gap>0;gap/=2){
        for(int i=gap;i<=n;i++){
            int temp=v[i],j;
            for(j=i;j>=gap&&v[j-gap]>=temp;j-=gap)
                v[j]=v[j-gap];
            v[j]=temp;
        }
    }
}
// *******END**SHELLSORT*****
*/
void heapify(int v[],int n,int x){
    int largest=x;
    int l=2*x, r=2*x+1;

    if(l<=n&&v[largest]<=v[l])
        largest=l;
    if(r<=n&&v[largest]<=v[r])
        largest=r;
    if(largest!=x){
        std::swap(v[largest],v[x]);
        heapify(v,n,largest);
    }
}

void heapsort(int v[],int n){
    for(int i=n/2;i>0;i--)
        heapify(v,n,i);
    for(int i=n;i>0;i--){
        std::swap(v[1],v[i]);
        heapify(v,i-1,1);
    }
}

int main()
{
    citire(v,N);
    heapsort(v,N);
    afis(v,N);
}