cool

#include <iostream>
#include <vector>
#include<string>
using namespace std;
const int64_t INVALID = -(1e18);

struct Node
{
    int l;
    int r;
    int64_t x;
    int64_t y;
    void node(int64_t xx,int64_t yy,int ll,int rr)
    {
        l = ll;
        r =rr;
        y =yy;
        x = xx;
    }
};


vector<Node> graph;

int create(int64_t x,int64_t y,int l,int r)
{
    Node a;
    a.node(x,y,l,r);
    graph.push_back(a);
    return graph.size()-1;
}

int merges(int indL,int indR)
{
    if(indL == -1)
        return indR;
    if(indR == -1)
        return indL;
    if(graph[indL].y > graph[indR].y)
    {
        graph[indL].r = merges(graph[indL].r, indR);
        return indL;
    }
    else
    {
        graph[indR].l = merges(indL,graph[indR].l);
        return indR;
    }
}

pair<int,int> split(int indT,int64_t x0)
{
    if(indT == -1)
        return make_pair(-1,-1);
    if(graph[indT].x <= x0)
    {
        pair<int,int> p = split(graph[indT].r, x0);
        graph[indT].r = p.first;
        return make_pair(indT,p.second);
    }
    else
    {
        pair<int,int> p = split(graph[indT].l, x0);
        graph[indT].l = p.second;
        return make_pair(p.first,indT);
    }

}

int64_t leftE(int indT)
{
    int yk = indT;
    while(graph[yk].l != -1)
    {
        yk  =graph[yk].l;
    }
    return graph[yk].x;
}

int64_t rightE(int indT)
{
    int yk = indT;
    while(yk != -1)
    {
        if(graph[yk].r != -1)
            yk  =graph[yk].r;
        else
            break;
    }
    return graph[yk].x;
}

int add(int indT,int64_t x,int64_t y)
{
    pair<int,int> p = split(indT, x);
    pair<int,int> p2 = split(p.first, x-1);
    return merges(merges(p2.first,create(x,y,-1,-1)),p.second);
}

int removes(int indT,int64_t x)
{
    pair<int,int> p = split(indT, x);
    pair<int,int> p2 = split(p.first, x-1);
    return merges(p2.first,p.second);
}

pair<bool,int> finds(int indT,int64_t x)
{
    pair<int,int> p = split(indT, x);
    pair<int,int> p2 = split(p.first, x-1);
    return make_pair(p2.second != -1,merges(merges(p2.first,p2.second),p.second));
}

pair<int64_t,int> next(int indT,int64_t x)
{
    pair<int,int> p = split(indT, x);
    if(p.second == -1)
        return make_pair(INVALID,merges(p.first,p.second));
    int ans = leftE(p.second);
    return make_pair(ans,merges(p.first,p.second));
}
pair<int64_t,int> prev(int indT,int64_t x)
{
    pair<int,int> p = split(indT, x-1);
    if(p.first == -1)
        return make_pair(INVALID,merges(p.first,p.second));
    int ans = rightE(p.first);
    return make_pair(ans,merges(p.first,p.second));
}

int main()
{
    string s;
    int indT = -1;
    while(cin >> s)
    {
        int64_t x;
        cin >> x;
        if(s == "insert")
        {
            indT = add(indT,x,rand());
        }
        if(s == "delete")
        {
            indT = removes(indT,x);
        }
        if(s == "exists")
        {
            pair<bool,int> f = finds(indT,x);
            indT = f.second;
            if(f.first)
            {
                cout << "true\n";
            }
            else
                cout << "false\n";
        }
        if(s == "next")
        {
            pair<int64_t,int> p = next(indT, x);
            indT = p.second;
            if(p.first == INVALID)
                cout << "none\n";
            else
                cout << p.first << "\n";
        }
        if(s == "prev")
        {
            pair<int64_t,int> p = prev(indT, x);
            indT = p.second;
            if(p.first == INVALID)
                cout << "none\n";
            else
                cout << p.first << "\n";
        }
    }
    return 0;
}