#include <iostream>
#include <vector>
#include <cmath>
#include <set>
#include <deque>
#include <queue>
#include <algorithm>
#include <stack>
#include <map>
#include <string>
#include <iomanip>
#include <fstream>
#include <random>
#include <chrono>
#include <unordered_map>
#define _GLIBCXX_DEBUG
#define all(v) v.begin(), v.end()
#define ll long long
#define ld long double
#define lb lower_bound
#define ub upper_bound
#define len(v) (ll)v.size()
#define last(v) (ll)v[len(v) - 1]
#define fi first
#define se second
#pragma GCC optimize("O3")
#pragma GCC target("avx2")
#pragma GCC optimize("unroll-loops")

#pragma GCC optimize("Ofast,unroll-loops")
#pragma GCC target("avx,avx2,fma,sse4")

#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
#pragma GCC target("avx,avx2,sse,sse2,sse3,ssse3,sse4,sse4.1,sse4.2,mmx,abm")
using namespace std;
const ll inf = 1e9;
const ll MAXN = 3e5 + 1;
const ll MAXM = 1e5 + 1;
const int logn = 29;
const ll m = 1e9;

mt19937 rnd(0);

template<class T>
istream& operator>>(istream& in, vector<T>& a) {
    for (auto& i : a)
        in >> i;
    return in;
}
template<class T>
ostream& operator<<(ostream& out, vector<T>& a) {
    for (auto& i : a)
        out << i << " ";
    return out;
}

struct Node {
    int key;
    Node* l;
    Node* r;
    Node(int val) {
        l = NULL;
        r = NULL;
        key = val;
    }
};
Node* root = NULL;

void insert(int key) {
    if (root == NULL) {
        root = new Node(key);
        return;
    }
    Node* cur = root;
    while (cur && cur->key != key) {
        if (cur->key > key && cur->l == NULL) {
            cur->l = new Node(key);
            return;
        }
        if (cur->key < key && cur->r == NULL) {
            cur->r = new Node(key);
            return;
        }
        if (cur->key > key)
            cur = cur->l;
        else
            cur = cur->r;
    }
}

Node* srch(int key) {
    Node* cur = root;
    while (cur && cur->key != key) {
        if (cur->key > key)
            cur = cur->l;
        else
            cur = cur->r;
    }
    return cur;
}

Node* next(int x) {
    Node* cur = root;
    Node* succ = NULL;
    while (cur != NULL) {
        if (cur->key > x) {
            succ = cur;
            cur = cur->l;
        } else
            cur = cur->r;
    }
    return succ;
}

Node* prev(int x) {
    Node* cur = root;
    Node* succ = NULL;
    while (cur != NULL) {
        if (cur->key < x) {
            succ = cur;
            cur = cur->r;
        } else
            cur = cur->l;
    }
    return succ;
}

Node* minimum(Node* x) {
    if (x->l == NULL)
        return x;
    return minimum(x->l);
}

Node* del(Node* v, int z) {
    if (v == NULL) return v;
    if (z < v->key)
        v->l = del(v->l, z);
    else if (z > v->key)
        v->r = del(v->r, z);
    else if (v->l != NULL && v->r != NULL) {
        v->key = minimum(v->r)->key;
        v->r = del(v->r, v->key);
    }
    else {
        if (v->l != NULL)
            v = v->l;
        else if (v->r != NULL) {
            v = v->r;
        }
        else
            v = NULL;
    }
    return v;
}

string tp;
int x;
void solve() {
    //ofstream fout("numbers.out");
    while (cin >> tp) {
        cin >> x;
        if (tp == "insert") insert(x);
        else if (tp == "delete") del(root, x);
        else if (tp == "exists") {
            auto ans = srch(x);
            if (ans == NULL) cout << "false" << endl;
            else cout << "true" << endl;
        }
        else if (tp == "next") {
            auto ans = next(x);
            if (ans == NULL) cout << "none" << endl;
            else cout << ans->key << endl;
        }
        else {
            auto ans = prev(x);
            if (ans == NULL) cout << "none" << endl;
            else cout << ans->key << endl;
        }
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    solve();

    return 0;
};