#include <fstream>

using namespace std;

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

class maxHeap
{
    private:
        int h[500001];
        int heapSize = 0;
        int parent(int node);
        int leftChild(int node);
        int rightChild(int node);
        void downHeapUtil(int node, int sz);

    public:
        int size();
        int top();
        void upHeap(int node);
        void downHeap(int node);
        void buildHeap();
        void push(int value);
        void staticPush(int value);
        void pop();
        void sort();
        void print();
};

int maxHeap::size()
{
    return heapSize;
}

int maxHeap::top()
{
    return h[1];
}

int maxHeap::parent(int node)
{
    return node / 2;
}

int maxHeap::leftChild(int node)
{
    return node * 2;
}

int maxHeap::rightChild(int node)
{
    return node * 2 + 1;
}

void maxHeap::upHeap(int node)
{
    while (node > 1 && h[node] > h[parent(node)])
    {
        swap(h[node], h[parent(node)]);
        node = parent(node);
    }
}

void maxHeap::downHeapUtil(int node, int sz)
{
    int child = 0;
    do
    {
        child = 0;

        if (leftChild(node) <= sz)
        {
            child = leftChild(node);

            if (rightChild(node) <= sz && h[rightChild(node)] >= h[leftChild(node)])
                child = rightChild(node);

            if (h[node] >= h[child])
                child = 0;
        }

        if (child)
        {
            swap(h[node], h[child]);
            node = child;
        }

    }while (child);
}

void maxHeap::downHeap(int node)
{
    downHeapUtil(node, heapSize);
}

void maxHeap::buildHeap()
{
    for (int i=heapSize/2; i>=1; i--)
        downHeap(i);
}

void maxHeap::push(int value)
{
    heapSize++;
    h[heapSize] = value;
    upHeap(heapSize);
}

void maxHeap::staticPush(int value)
{
    heapSize++;
    h[heapSize] = value;
}

void maxHeap::pop()
{
    h[1] = h[heapSize], h[heapSize] = 0;
    heapSize--;
    downHeap(1);
}

void maxHeap::sort()
{
    for (int i=heapSize; i>=2; i--)
    {
        swap(h[1], h[i]);
        downHeapUtil(1, i-1);
    }
}

void maxHeap::print()
{
    for (int i=1; i<=heapSize; i++)
        g << h[i] << " ";
}

maxHeap heap;

int n;

int main()
{
    f >> n;
    for (int i=1; i<=n; i++)
    {
        int x; f >> x;
        heap.staticPush(x);
    }

    heap.buildHeap();
    heap.sort();
    heap.print();

    return 0;
}