Splay 10分求助

写了一晚上以后就只得了十分（在普通数据的题里能过），发现了这篇讨论，于是照着解答的人的思路改了改，还是炸了/kel

有没有大佬来帮忙看看我的代码呀？码风一般请见谅

//最早的代码

#include <cstdio>
using namespace std;

#define int long long

/***************快读***************/

namespace IO {
char buf[1<<21], *p1 = buf, *p2 = buf, buf1[1<<21];
inline char gc () {return p1 == p2 && (p2 = (p1 = buf) + fread (buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;}

#ifndef ONLINE_JUDGE
#endif

#define gc getchar

template<class I>
inline void read(I &x) {
    x = 0; I f = 1; char c = gc();
    while(c < '0' || c > '9') {if(c == '-') f = -1; c = gc(); }
    while(c >= '0' && c <= '9') {x = x * 10 + c - '0'; c = gc(); }
    x *= f;
}

template<class I>
inline void write(I x) {
    if(x == 0) {putchar('0'); return;}
    I tmp = x > 0 ? x : -x;
    if(x < 0) putchar('-');
    int cnt = 0;
    while(tmp > 0) {
        buf1[cnt++] = tmp % 10 + '0';
        tmp /= 10;
    }
    while(cnt > 0) putchar(buf1[--cnt]);
}

#define in(x) read(x)
#define outn(x) write(x), putchar('\n')
#define out(x) write(x), putchar(' ')

} using namespace IO;

/***************快读***************/

#define maxn 1000010

struct Splay_Fold{
    #define debug(); puts("Orz");

    struct Splay_tree{
        int son[2];
        int fa;
        int cnt;
        int size;
        int val;
    }tree[maxn];

    int tree_cnt,root;

    void Clear(int ID){
        tree[ID].son[0]=tree[ID].son[1]=0;
        tree[ID].fa=0;
        tree[ID].size=0;
        tree[ID].cnt=0;
        tree[ID].val=0;
    }

    void pushup(int ID){
        if(ID){
            tree[ID].size=tree[ID].cnt;
            if(tree[ID].son[0]){
                tree[ID].size+=tree[tree[ID].son[0]].size;
            }
            if(tree[ID].son[1]){
                tree[ID].size+=tree[tree[ID].son[1]].size;
            }
        }
    }

    bool Son(int ID){
        return tree[tree[ID].fa].son[1]==ID;
    }

    void rotate(int ID){
        int fa=tree[ID].fa;
        int gra_fa=tree[fa].fa;
        int ty_son=Son(ID);
        tree[fa].son[ty_son]=tree[ID].son[ty_son^1];
        tree[tree[ID].son[ty_son^1]].fa=fa;
        tree[ID].son[ty_son^1]=fa;
        tree[fa].fa=ID;
        tree[ID].fa=gra_fa;
        if(gra_fa){
            tree[gra_fa].son[tree[gra_fa].son[1]==fa]=ID;
        }
        pushup(fa);
        pushup(ID);
    }

    void Splay(int ID,int goal){
        for(int index;(index=tree[ID].fa)!=goal;rotate(ID)){
            if(tree[index].fa!=goal){
                if(Son(ID)==Son(index)){
                    rotate(index);
                }
                else{
                    rotate(ID);
                }
            }
        }
        if(goal==0){
            root=ID;
        }
    }

    void insert(int val){
        if(!root){
            ++tree_cnt;
            tree[tree_cnt].son[0]=tree[tree_cnt].son[1]=0;
            tree[tree_cnt].fa=0;
            tree[tree_cnt].size=tree[tree_cnt].cnt++;
            tree[tree_cnt].val=val;
            root=tree_cnt;
            return;
        }
        int index=root,fa=0;
        while(19260817){
            if(val==tree[index].val){
                ++tree[index].cnt;
                pushup(index);
                pushup(fa);
                Splay(index,0);
                return;
            }
            fa=index;
            index=tree[index].son[tree[index].val<val];
            if(!index){
                ++tree_cnt;
                tree[tree_cnt].son[0]=tree[tree_cnt].son[1]=0;
                tree[tree_cnt].size=tree[tree_cnt].cnt=1;
                tree[tree_cnt].fa=fa;
                tree[tree_cnt].val=val;
                tree[fa].son[tree[fa].val<val]=tree_cnt;
                pushup(fa);
                Splay(tree_cnt,0);
                return;
            }
        }
    }

    int NumQuery(int ID){
        int index=root;
        while(19260817){
            if(tree[index].son[0]&&tree[tree[index].son[0]].size>=ID){
                index=tree[index].son[0];
            }
            else{
                int temp=(tree[index].son[0]?tree[tree[index].son[0]].size:0)+tree[index].cnt;
                if(temp>=ID){
                    return tree[index].val;
                }
                ID-=temp;
                index=tree[index].son[1];
            }
        }
    }

    int RankQuery(int val){
        int index=root,res=0;
        while(19260817){
            if(tree[index].val>val){
                index=tree[index].son[0];
            }
            else{
                res+=(tree[index].son[0]?tree[tree[index].son[0]].size:0);
                if(tree[index].val==val){
                    Splay(index,0);
                    return res+1;
                }
                res+=tree[index].cnt;
                index=tree[index].son[1];
            }
        }
    }

    int Pre(){
        int index=tree[root].son[0];
        while(tree[index].son[1]){
            index=tree[index].son[1];
        }
        return index;
    }

    int Suf(){
        int index=tree[root].son[1];
        while(tree[index].son[0]){
            index=tree[index].son[0];
        }
        return index;
    }

    void CutOut(int val){
        int rank=RankQuery(val);
        if(tree[root].cnt>1){
            --tree[root].cnt;
            pushup(root);
            return;
        }
        if(!tree[root].son[0]&&!tree[root].son[1]){
            Clear(root);
            root=0;
            return;
        }
        if(!tree[root].son[0]){
            int old_root=root;
            root=tree[root].son[1];
            tree[root].fa=0;
            Clear(old_root);
            return;
        }
        if(!tree[root].son[1]){
            int old_root=root;
            root=tree[root].son[0];
            tree[root].fa=0;
            Clear(old_root);
            return;
        }
        int left=Pre(),old_root=root;
        Splay(left,0);
        tree[root].son[1]=tree[old_root].son[1];
        tree[tree[old_root].son[1]].fa=root;
        Clear(old_root);
        pushup(root);
    }
}splay;

int n,m;
int last;
int ans;

signed main(){
    read(n),read(m);
    for(int i=1,opt;i<=n;i++){
        read(opt);
        splay.insert(opt);
    }
    for(int i=1,opt,x;i<=m;i++){
        read(opt),read(x);
        x^=last;
        if(opt==1){
            splay.insert(x);
        }
        else if(opt==2){
            splay.CutOut(x);
        }
        else if(opt==3){
            last=(splay.RankQuery(x));
            ans^=last;
        }
        else if(opt==4){
            last=(splay.NumQuery(x));
            ans^=last;
        }
        else if(opt==5){
            splay.insert(x);
            last=(splay.tree[splay.Pre()].val);
            ans^=last;
            splay.CutOut(x);
        }
        else if(opt==6){
            splay.insert(x);
            last=(splay.tree[splay.Suf()].val);
            ans^=last;
            splay.CutOut(x);
        }
    }
    outn(ans);
    return 0;
}