#include <iostream>
#include <fstream>
#include <algorithm>

using namespace std;

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

struct AVL_Node{
    int key, height;
    AVL_Node* left;
    AVL_Node* right;
};

int height_node(AVL_Node* Root)
{
    int l = (Root -> left != NULL) ? Root -> left -> height : 0;
    int r = (Root -> right != NULL) ? Root -> right -> height : 0;
    return 1 + max(l, r);
}

AVL_Node* LL_rotation(AVL_Node* Root)
{
    AVL_Node* temp = Root -> left;
    Root -> left = temp -> right;
    temp -> right = Root;
    Root -> height = height_node(Root);
    temp -> height = height_node(temp);
    return temp;
}

AVL_Node* RR_rotation(AVL_Node* Root)
{
    AVL_Node* temp = Root -> right;
    Root -> right = temp -> left;
    temp -> left = Root;
    Root -> height = height_node(Root);
    temp -> height = height_node(temp);
    return temp;
}

AVL_Node* LR_rotation(AVL_Node* Root)
{
    Root -> left = RR_rotation(Root -> left);
    return LL_rotation(Root);
}

AVL_Node* RL_rotation(AVL_Node* Root)
{
    Root -> right = LL_rotation(Root -> right);
    return RR_rotation(Root);
}

AVL_Node* balance(AVL_Node* Root)
{
    int l = (Root -> left != NULL) ? Root -> left -> height : 0;
    int r = (Root -> right != NULL) ? Root -> right -> height : 0;
    Root -> height =  1 + max(l, r);
    int ll, rr;
    if (r > l + 1)
    {
        ll = (Root -> right -> left != NULL) ? Root -> right -> left -> height : 0;
        rr = (Root -> right -> right != NULL) ? Root -> right -> right -> height : 0;
        if (rr > ll)
            Root = RR_rotation(Root);
        else
            Root = RL_rotation(Root);
    }
    else if (l > r + 1)
    {
        ll = (Root -> left -> left != NULL) ? Root -> left -> left -> height : 0;
        rr = (Root -> left -> right != NULL) ? Root -> left -> right -> height : 0;
        if (ll > rr)
            Root = LL_rotation(Root);
        else
            Root = LR_rotation(Root);
    }
    return Root;
}

AVL_Node* insert(AVL_Node* Root, int key)
{
    if (Root == NULL)
    {
        Root = new AVL_Node;
        Root -> key = key;
        Root -> left = NULL;
        Root -> right = NULL;
        Root -> height = 1;
        return Root;
    }
    if (key < Root -> key)
        Root -> left = insert(Root -> left, key);
    else
        Root -> right = insert(Root -> right, key);
    return balance(Root);
}

void sort(AVL_Node* Root)
{
    if (Root)
    {
        if (Root -> left != NULL)
            sort(Root -> left);
        out << Root -> key << " ";
        if (Root -> right != NULL)
            sort(Root -> right);
    }
}

int n;
AVL_Node* AVL;

int main()
{
    in >> n;
    int x;
    for (int i = 1; i <= n; i++)
    {
       in >> x;
       AVL = insert(AVL, x);
    }
    sort(AVL);
    out.close();
    return 0;
}