#include <iostream>
#include <fstream>
#include <algorithm>
#include <string>
#include <set>

using namespace std;

int maxHalf = 0;
bool beOrNotToBe = 1;
std::ofstream ofs("tst.out");
struct Node{
    int v;
    Node *l, *r;
    int h, k, lc, ans;
    bool isL, isR, pr;
    Node (int n ){ v = n; l = r = 0; ans = lc = h = k = 0; pr=true;isL = isR = 0;}
    string toString(){
        return std::to_string(v) + " h=" +std::to_string(h) + " versh=" + std::to_string(k)
            + " isL=" + std::to_string(isL) + " isR=" + std::to_string(isR)
            + " lc=" + std::to_string(lc) + " ans=" + std::to_string(ans);
    }
};
Node * root;
set<Node*> nodeSet;

void insert(Node * t, int n){
    if (t == 0)
    {
        t = new Node(n);
    }
    else
    {
        if (n < t->v)
        {
            if (t->l)
                insert(t->l, n);
            else
                t->l = new Node(n);
        }
        else
        if (n > t->v)
        {
            if (t->r)
                insert(t->r, n);
            else
                t->r = new Node(n);
        }
    }
}

void print(Node * t){
    if (t != 0){

        if (t->pr) ofs << t->v << std::endl;
        //std::cout << t->toString() << std::endl;
        print(t->l);
        print(t->r);
    }
}

void traverse(Node * t){
    if (t != 0){
        if (t->l) traverse(t->l);
        if (t->r) traverse(t->r);
        if (t->l==0 && t->r==0) {t->h = 0;}
        if (t->l    && !t->r) {t->h = t->l->h + 1; t->isL = 1;}
        if (!t->l   &&  t->r) {t->h = t->r->h + 1; t->isR = 1;}
        if (t->l    &&  t->r) {
            t->h = std::max(t->l->h, t->r->h) + 1;
            t->k = t->l->h + t->r->h + 2;
            if (t->k >  maxHalf) {maxHalf = t->k; nodeSet.clear();}
            if (t->k == maxHalf) {nodeSet.insert(t);}
            if (t->l->h >   t->r->h) {t->isL = 1;}
            if (t->l->h <   t->r->h) {t->isR = 1;}
            if (t->l->h ==  t->r->h) {t->isL = t->isR = 1;}
        }
    }
}

void traverse2(Node * t){
    if(t){
        if(t->l) traverse2(t->l);
        if(t->r) traverse2(t->r);
        if (t->l==0 && t->r==0) t->lc = 1;

        int n = 0;
        if ((t->l && !t->r) || (t->l && t->r && (t->l->h > t->r->h))) n+= t->l->lc;
        if ((t->r && !t->l) || (t->r && t->l && (t->r->h > t->l->h))) n+= t->r->lc;
        if (t->r && t->l && (t->r->h == t->l->h)) n += t->r->lc + t->l->lc;

        if (n) t->lc = n;
    }
}

void traverse3(Node * t, int n){
    if (t != 0){
        t->ans += t->lc * n;
        if (t->l && t->isL) traverse3(t->l, n);
        if (t->r && t->isR) traverse3(t->r, n);
    }
}
void del(Node * t){
    if (t->l && !t->r){ t->v = t->l->v; t->r = t->l->r; t->l = t->l->l;}
    else
    if (t->r && !t->l){ t->v = t->r->v; t->l = t->r->l; t->r = t->r->r;}
    else
    if (t->r && t->l){
        if (t->r->l == 0) { t->v = t->r->v; t->r = t->r->r;}
        else{
            Node * tmp = t->r->l;
            Node * tmp2 = t->r;
            while(tmp->l){ tmp = tmp->l; tmp2 = tmp2->l;}
            tmp2->l = tmp->r;
            t->v = tmp->v;
        }
    }
    else
    if (!t->r && !t->l){ t->pr = false;}
}
void traverse4(Node * t){
    if(t){
        traverse4(t->l);
        if (beOrNotToBe && t->ans && t->ans%2==0){
            beOrNotToBe = 0;
            cout << t->v << endl;
            del(t);
        }
        traverse4(t->r);
    }
}

int main(){
    std::ifstream ifs("tst.in");

    root = new Node(-10000); ifs>>root->v; int kk = 1;
    if (root->v == -10000) return 0;
    while (!ifs.eof()){
        kk ++;
        int tmp; ifs>>tmp; insert(root, tmp);
    }
    if (kk == 1){
        ofs << root->v;
    }
    //else if (kk == 2){
    //  if (root->l) ofs << root->v << endl << root->l->v;
    //  if (root->r) ofs << root->v << endl << root->r->v;
    //}
    else{
        traverse(root);
        if ((root->l && !root->r) || (root->r && !root->l))
        {
            if (root->h == maxHalf)
                nodeSet.insert(root);
            if (root->h > maxHalf){
                nodeSet.clear();
                nodeSet.insert(root);
            }
        }
        //for (Node * t : nodeSet) { t->isL = t->isR = 1;}
        traverse2(root);
        for (Node * t: nodeSet) {
            if (t->l && t->r){
                t->ans += t->l->lc * t->r->lc;
                traverse3(t->l, t->r->lc);
                traverse3(t->r, t->l->lc);
            }
            if (t->l && !t->r){
                t->ans += t->l->lc;
                traverse3(t->l, 1);
            }
            if (!t->l && t->r){
                t->ans += t->r->lc;
                traverse3(t->r, 1);
            }
        }
        traverse4(root);
        print(root);
    }
}