#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int n, m;
 
struct Data { int num; };
struct Tnode {
    Data d;
    Tnode *left, *right;
};
struct BST {
private:
    int cnt=0;
    Tnode *root=NULL;
 
public:
    void setRoot(Tnode *t) { root=t; }
    Tnode *getRoot() { return root; }
    Tnode *searchMin(Tnode *t, Tnode *p);
    Tnode *insert(Tnode *t, Data d);
    void deleteNode(Tnode *t, Tnode *p, Data d);
    Tnode *search(Tnode *t, Data d);
    bool isEmpty();
    int getCnt();
    Tnode Inorder(Tnode *t, int num);
    //t : 현재 노드(위치), p : 부모 노드
};
 
Tnode *BST::search(Tnode *t, Data d) {
    if(t==NULL) return NULL;
 
    if(t->d.num==d.num)
        return t;
    else if(t->d.num<d.num)
        return search(t->right, d);
    else
        return search(t->left, d);
}
 
Tnode *BST::searchMin(Tnode *t, Tnode *p) { //최솟값 노드의 부모 노드 반환
    if(t->left==NULL) return p; //현재 노드 t의 값이 최소
    else return searchMin(t->left, t);
}
 
Tnode *BST::insert(Tnode *t, Data d) {
    if(t==NULL) {
        t=(Tnode *)malloc(sizeof(Tnode));
        t->d=d;
        t->left=t->right=NULL;
        cnt++;
    }
    else if(t->d.num>d.num)
        t->left=insert(t->left, d);
    else
        t->right=insert(t->right, d);
    return t;
}
 
void BST::deleteNode(Tnode *t, Tnode *p, Data d) {
    if(t==NULL) return; //삭제할 노드 존재X
 
    if(t->d.num==d.num) { //삭제할 노드 찾았을 때
        if(t->left==NULL&&t->right==NULL) { //1. 자식 노드 없음
            if(p==NULL) root=NULL; //노드가 하나만 존재했을 때
 
            else if(p->left==t) p->left=NULL;
            else p->right=NULL;
            free(t);
 
            cnt--;
        }
        else if(t->right==NULL) { // 2-1. 왼쪽 자식만 존재
            if(p==NULL) root=t->left;
 
            else if(p->left==t) p->left=t->left;
            else p->right=t->left;
            free(t);
 
            cnt--;
        }
        else if(t->left==NULL) { // 2-2. 오른쪽 자식만 존재
            if(p==NULL) root=t->right;
 
            else if(p->left==t) p->left=t->right;
            else p->right=t->right;
            free(t);
 
            cnt--;
        }
        else { //3. 자식 노드 둘
            Tnode *mn=searchMin(t->right, t); //오른쪽 서브트리에서 최솟값 노드의 부모 노드 찾음
            if(mn==t) { //내 오른쪽 서브 트리의 루트 노드가 최소
                t->d = mn->right->d;
                deleteNode(mn->right, mn, mn->right->d);
            }
            else {
                t->d = mn->left->d;
                deleteNode(mn->left, mn, mn->left->d);
            }
        }
    }
    else if(t->d.num>d.num)
        deleteNode(t->left, t, d);
    else
        deleteNode(t->right, t, d);
}
bool BST::isEmpty() {
    return !cnt;
}
int BST::getCnt() {
    return cnt;
}
void Inorder(Tnode *t) {
    if(t==NULL) {
        m--;
        return;
    }
    Inorder(t->left);
    if(m==0) {
        printf("%d", t->d.num);
    }
    Inorder(t->right);
}
 
int main() {
    scanf("%d", &n);
    Data d;
    BST bst;
 
    for(int i=0; i<n; i++) {
        scanf("%d" ,&d.num);
        bst.setRoot(bst.insert(bst.getRoot(), d));
        //bst.deleteNode(bst.getRoot(), NULL, num);
    }
    Inorder(bst.getRoot());
}