#include <iostream>
#include<fstream>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
ofstream fout("algsort.out");
struct Nod
{
    int val,height,weight;
    Nod *left, *right;
};
Nod *rad;
//greutate
int weight(Nod *k)
{
    int lf,rt;
    if(k->left==NULL && k->right==NULL)
        return 1;
    if(k->left==NULL)
        rt=1;
    else
        lf=k->left->weight;

    if(k->right==NULL)
        rt=1;
    else
        rt=k->right->weight;
    return lf+rt+1;
}
//inaltimea
int height(Nod *k)
{
    int lf,rt;
    if(k->left==NULL)
        lf=0;
    else
        lf=k->left->height;

    if(k->right==NULL)
        rt=0;
    else
        rt=k->right->height;
    return lf-rt;
}
int dif(Nod *k)
{
    int lf,rt;
    if(k->left==NULL)
        lf=0;
    else
        lf=k->left->height;

    if(k->right==NULL)
        rt=0;
    else
        rt=k->right->height;
    return lf-rt;
}
//rotatie la dreapta
Nod* right_rotate(Nod *k)
{
    Nod *lf;
    lf=k->left;
    k->left=lf->right;
    lf->right=k;

    k->height=height(k);
    k->weight=weight(k);
    lf->weight=weight(lf);
    lf->height=height(lf);

    return lf;
}
//rotatir la stanga
Nod* left_rotate(Nod *k)
{
    Nod *rt;
    rt=k->right;
    k->right=rt->left;
    rt->left=k;

    k->height=height(k);
    k->weight=weight(k);
    rt->weight=weight(rt);
    rt->height=height(rt);

    return rt;
}
//balansare
Nod* balance(Nod *k)
{
    int d;
    k->height=height(k);
    k->weight=weight(k);
    d=dif(k);
    if(d > 1)
    {
        if(dif(k->left) < 0)
            k->left=left_rotate(k->left);
        return right_rotate(k);
    }

    if(d < -1)
    {
        if(dif(k->right) > 0)
            k->right=right_rotate(k->right);
        return left_rotate(k);
    }

    return k;
}
//inserare val in avl
Nod* insert_nod(Nod *k, int x)
{
    if(k==NULL)
    {
        //creez un nou nod
        k=new Nod;
        k->val=x;
        k->height=1;
        k->weight=1;
        k->left=NULL;
        k->right=NULL;
        return k;
    }
    else
    {
        if(k->val > x) k->left=insert_nod(k->left,x);
        else
            k->right=insert_nod(k->right,x);
    }
    return balance(k);
}
//cautare val
Nod* search_nod(Nod *k, int x)
{
    if(k==NULL) return NULL;
    if(k->val == x) return k;
    else
    {
        if(k->val > x)
            return search_nod(k->left,x);
        else
            return search_nod(k->right,x);
    }
}
//stergere val
Nod* delete_nod(Nod *k,int x)
{
    Nod *node;
    if(k==NULL)
        return k;
    if(k->val!=x)
    {
        if(k->val > x)
            k->left=delete_nod(k->left,x);
        else
            k->right=delete_nod(k->right,x);
    }
    else
    {
        if(k->right==NULL)
        {
            if(k->left==NULL)
            {
                node=k->left;
                return node;
            }
            else
            {
                node=k->left;
                k=node;
            }
        }
        else
        {
            if(k->left==NULL)
            {
                node=k->right;
                return node;
            }
            else
            {
                node=k->right;
                while(node->left!=NULL)
                    node=node->left;
                swap(k->val,node->val);
                k->right=delete_nod(k->right, node->val);
            }
        }

    }
    k->height=height(k);
    return balance(k);
}
void nthelement(Nod *p, int k)
{
    if(p==NULL) return;
    if(weight(p->left)==k-1)
    {
        fout<<p->val<<"\n";
        return;
    }
    else
    {
        if(weight(p->left) < k-1) nthelement(p->left, k);
        else
            nthelement(p->right, k);
    }
}
void inorder(Nod *k)
{
    if(k==NULL) return;
    inorder(k->left);
    fout<<k->val<<" ";
    inorder(k->right);
}
int main()
{
    int i,x,n;
    ifstream fin("algsort.in");
    //creare radacina
    rad=new Nod;
    rad=NULL;

    fin>>n;
    for(i=1;i<=n;++i)
    {
        fin>>x;
        if(search_nod(rad,x)==NULL)
            rad=insert_nod(rad,x);
    }
    fin.close();
    inorder(rad);
    fout<<"\n";

    fout.close();
    return 0;
}