#include <bits/stdc++.h>
using namespace std;

fstream in ( "algsort.in" , ios::in  );
fstream out( "algsort.out", ios::out );

#define fastcall __attribute__((optimize("-O3")))
#define inline __inline__ __attribute__((always_inline))

struct T {
    T *ln, *rn, *pn;
    bool col; int key;
    
    T() :
        key(-1), pn(NULL), ln(NULL), rn(NULL), col(false) {}

    T( int _key, T *_pn, T *_ln, T *_rn ) :
        key(_key), pn(_pn), ln(_ln), rn(_rn), col(true) {}
} *rot, *nil;

inline fastcall T* gnd( T *&tn ) {
    return tn -> pn == nil ? nil : tn -> pn -> pn;
}

inline fastcall T* und( T *&tn ) {
    T *an = gnd( tn );
    
    if( an == nil )
        return nil;
    
    return tn -> pn == an -> ln ? an -> rn : an -> ln;
}

inline fastcall void rle( T *&tn ) {
    T *an = tn -> rn;
    tn -> rn = an -> ln;
    an -> ln = tn; tn = an;
    
    return;
}

inline fastcall void rri( T *&tn ) {
    T *an = tn -> ln;
    tn -> ln = an -> rn;
    an -> rn = tn; tn = an;
    
    return;
}

inline fastcall void ins( T *&tn, int key ) {
    T *gn, *un;
    
    if( tn == nil )
        tn = new T( key, nil, nil, nil );
    else {
        while( true ) {
            if( tn -> key < key ) {
                if( tn -> rn == nil ) {
                    tn -> rn = new T( key, tn, nil, nil );
                    tn = tn -> rn; break;
                }
                else
                    tn = tn -> rn;
            }
            else {
                if( tn -> ln == nil ) {
                    tn -> ln = new T( key, tn, nil, nil );
                    tn = tn -> ln; break;
                }
                else
                    tn = tn -> ln;
            }
        }
    }
    
    while( true ) {
        if( tn == rot ) {
            tn -> col = false;
            break;
        }
        else
        if( tn -> pn -> col == false )
            break;
        else {
            gn = gnd( tn ); un = und( tn );
                
            if( tn -> pn -> col == true && gn -> col == true ) {
                tn -> col = true; un -> col = false;
                tn -> pn -> col = false; tn = gn;
            }
            else {
                if( tn -> pn == gn -> ln && tn == tn -> pn -> rn ) {
                    rle( tn -> pn );
                    tn = tn -> ln;
                }
                else
                if( tn -> pn == gn -> rn && tn == tn -> pn -> ln ) {
                    rri( tn -> pn );
                    tn = tn -> rn;
                }
                    
                tn -> pn -> col = false;
                gn -> col = true;
                    
                if( tn -> pn == gn -> ln )
                    rri( gn );
                else
                    rle( gn );
                    
                break;
            }
        }
    }
    
    while( tn -> pn != nil )
        tn = tn -> pn;
    
    return;
}

inline fastcall void pri( T *&tn ) {
    if( tn == nil )
        return;
    
    pri( tn -> ln );
    out << tn -> key << " ";
    pri( tn -> rn );
    
    return;
}

int main( void ) {
    ios::sync_with_stdio( false );
    rot = nil = new T;
    
    int n;
    in >> n;
    
    for( int i = 1; i <= n; i ++ ) {
        int x;
        in >> x;
        
        ins( rot, x );
    }
    
    pri( rot );
    
    return 0;
}