sgssdgdsg

#include <vector>
#include <iostream>
using namespace std;
struct node {
    node *l= nullptr, *r= nullptr;
    int key;
    node(int k) {
        this->key = k;
    }
};

struct binary_tree {
private:
    node *root = nullptr;
    node * search(node * cur, int k) {
        if (cur == nullptr) {
            return nullptr;
        }
        if (k == cur->key) {
            return cur;
        }

        if (k < cur->key) {
            return search(cur->l, k);
        } else {
            return search(cur->r, k);
        }
    }
    node * add(node *cur, int key) {
        if (cur == NULL) {
            return new node(key);
        }
        if (key < cur->key) {
            cur->l = add(cur->l, key);
        } else {
            cur->r = add(cur->r, key);
        }
        return cur;
    }

    void print(node *cur) {
        if (cur != nullptr) {
            print(cur->l);
            cout << cur->key << " ";
            print(cur->r);
        }
    }
    node *minimum(node *cur) {
        if (cur->l == nullptr) {
            return cur;
        }
        return minimum(cur->l);
    }
    node *maximim(node *cur) {
        if (cur->r == nullptr) return cur;
        return maximim(cur->r);
    }
    //*(cur).l == cur->l
    node * erase(node *cur, int key) {
        if (cur == nullptr) {
            return cur;
        }
        if (key < cur->key) {
            cur->l = erase(cur->l, key);
        } else if (key > cur->key) {
            cur->r = erase(cur->r, key);
        } else if (cur->l != nullptr && cur->r != nullptr) {
            cur->key = minimum(cur->r)->key;
            cur->r = erase(root->r, cur->key);
        } else {
            if (cur->l != nullptr) {
                cur = cur->l;
            } else if (cur->r != nullptr) {
                cur = cur->r;
            } else {
                cur = nullptr;
            }
        } return cur;
    };
public:
    bool search(int key) {
        if (search(root, key) == nullptr) {
            return 0;
        }
        return 1;
    }

    void add(int key) {
        if (!search(key)) {
            root = add(root, key);
        }
    }

    void print() {
        print(root);
    }

    void erase(int key) {

        erase(root, key);
    }
    int maximum() {
        return maximim(root)->key;
    }
};

int main() {
    binary_tree a;
    int x;
    cin >> x;
    while (x!=0) {
        a.add(x);
        cin >> x;
    } a.erase(a.maximum());
    cout << a.maximum();
    return 0;
}