题目大意：维护一个序列，支持以下操作：

1.在某个位置插入一个数

2.删除某个位置上的数

3.修改某个位置上的数

4.求某段区间中的次大值与区间中另一个数的异或值的最大值

强制在线

替罪羊树套Trie树。。。终于尼玛A了。。。7.4KB的大代码啊- –

插入和修改同带插入区间k小值 删除要打标记不能直接删

删除的时候注意 删除导致的不平衡不要重建 否则复杂度无法保证

因此每个节点维护一个max_size代表历史size最大值 判断不平衡时用这个变量来判断即可

注意访问替罪羊树的时候一定要判断当前节点是否已被删除- – 否则问题大大的- –

询问时先找到次小值 然后找异或的最大值 注意不要二分 直接在替罪羊树上找对应区间 具体写法详见代码(如果能找到函数在哪里的话- -)

还有啥注意事项。。。 变量重名，成员函数访问错误，友元函数不引用本结构体指针，失效的默认值，忘记重载delete。。。我也是醉了

尼玛万恶的360把我家的渣渣C-Free给杀了- – 调试功能爆炸了，只能gdb- – 调过样例之后就没心情再调了- –

#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define M 200200
#define L (1<<15)
#define ALPHA 0.88
using namespace std;

class Trie *null;

class Trie{
private:
	static queue<Trie*> bin;
public:
	Trie *son[2];
	int size;
	void* operator new (size_t,Trie *_,Trie *__,int ___)
	{
		static Trie *mempool,*C=mempool;
		Trie *re;
		if( !bin.empty() )
			re=bin.front(),bin.pop();
		else
		{
			if(C==mempool)
				mempool=(C=new Trie[L])+L;
			re=C++;
		}
		re->son[0]=_;
		re->son[1]=__;
		re->size=___;
		return re;
	}
	void operator delete (void *p)
	{
		bin.push((Trie*)p);
	}
	friend void Insert(Trie* &p,int num,int pos=1<<20)
	{
		if(p==null)
			p=new (null,null,0) Trie;
		p->size++;
		if(!pos) return ;
		if(num&pos)
			Insert(p->son[1],num,pos>>1);
		else
			Insert(p->son[0],num,pos>>1);

	}
	void Delete(int num,int pos=1<<20)
	{
		size--;
		if(!pos) return ;
		if(num&pos)
			son[1]->Delete(num,pos>>1);
		else
			son[0]->Delete(num,pos>>1);
	}
	int Get_Kth(int pos,int k)
	{
		if(!pos) return 0;
		if(k<=son[1]->size)
			return pos|son[1]->Get_Kth(pos>>1,k);
		else
			return son[0]->Get_Kth(pos>>1,k-son[1]->size);
	}
	int Get_Max(int pos,int x)
	{
		int temp=pos&x?1:0;
		if(!pos) return 0;
		if(son[!temp]->size)
			return pos|son[!temp]->Get_Max(pos>>1,x);
		else
			return son[temp]->Get_Max(pos>>1,x);
	}
	void Decomposition()
	{
		if(this==null)
			return ;
		son[0]->Decomposition();
		son[1]->Decomposition();
		delete this;
	}
};

class Kth_Getter{
private:
	int first,second;
public:
	Kth_Getter():first(-1),second(-1) {}
	bool Insert(int x)
	{
		if(x>first)
		{
			second=first;
			first=x;
			return true;
		}
		if(x>second)
			second=x;
		return false;
	}
	int Second()
	{
		return second;
	}
};

class Scapetree *nil,**to_rebuild;
int to_delete;

class Scapetree{
private:
	static queue<Scapetree*> bin;
public:
	static int stack[M],top;

	Scapetree *ls,*rs;
	int val,size,max_size;
	Trie *tree;

	void* operator new (size_t,Scapetree *_,Scapetree *__,int ___,int ____)
	{
		static Scapetree *mempool,*C=mempool;
		Scapetree *re;
		if( !bin.empty() )
			re=bin.front(),bin.pop();
		else
		{
			if(C==mempool)
				mempool=(C=new Scapetree[L])+L;
			re=C++;
		}
		re->ls=_;
		re->rs=__;
		re->val=___;
		re->size=____;
		re->max_size=____;
		re->tree=null;
		return re;
	}
	void operator delete (void *p)
	{
		bin.push((Scapetree*)p);
	}
	bool Check()
	{
		if((double)ls->max_size/max_size>ALPHA)
			return true;
		if((double)rs->max_size/max_size>ALPHA)
			return true;
		return false;
	}
	friend void Insert(Scapetree* &p,int pos,int val)
	{
		int temp=~p->val?1:0;
		if(p==nil)
		{
			p=new (nil,nil,val,1) Scapetree;
			Insert(p->tree,val);
			return ;
		}
		p->size++;Insert(p->tree,val);
		p->max_size=max(p->max_size,p->size);
		if(pos<=p->ls->size)
			Insert(p->ls,pos,val);
		else
			Insert(p->rs,pos-p->ls->size-temp,val);
		if(p->Check())
			to_rebuild=&p;
	}
	void Delete(int pos)
	{
		int temp=~val?1:0;
		if(pos<=ls->size)
			ls->Delete(pos);
		else
		{
			pos-=ls->size;
			if(pos==temp)
			{
				to_delete=val;
				val=-1;
			}
			else rs->Delete(pos-temp);
		}
		size--;tree->Delete(to_delete);
	}
	void Modify(int pos,int val)
	{
		int temp=~this->val?1:0;
		if(pos<=ls->size)
			ls->Modify(pos,val);
		else
		{
			pos-=ls->size;
			if(pos==temp)
			{
				to_delete=Scapetree::val;
				Scapetree::val=val;
			}
			else rs->Modify(pos-temp,val);
		}
		tree->Delete(to_delete);
		Insert(tree,val);
	}
	void Decomposition()
	{
		if(this==nil)
			return ;
		ls->Decomposition();
		if(~val) stack[++top]=val;
		rs->Decomposition();
		tree->Decomposition();
		delete(this);
	}
	void Get_2th(int l,int r,Kth_Getter& getter)
	{
		if( l==1 && r==size )
		{
			if( getter.Insert( tree->Get_Kth(1<<20,1) ) && size>=2 )
				getter.Insert( tree->Get_Kth(1<<20,2) );
			return ;
		}
		int temp=~val?1:0;
		if( temp && l<=ls->size+1 && r>=ls->size+1 )
			getter.Insert(val);
		if( l<=ls->size )
			ls->Get_2th(l,min(r,ls->size),getter);
		if( r>ls->size+temp )
			rs->Get_2th(max(l-(ls->size+temp),1),r-(ls->size+temp),getter);
	}
	int Get_Max(int l,int r,int val)
	{
		if( l==1 && r==size )
			return tree->Get_Max(1<<20,val);
		int re=-1,temp=~this->val?1:0;
		if( temp && l<=ls->size+1 && r>=ls->size+1 )
			re=max(re,val^this->val);
		if( l<=ls->size )
			re=max(re,ls->Get_Max(l,min(r,ls->size),val) );
		if( r>ls->size+temp )
			re=max(re,rs->Get_Max(max(l-(ls->size+temp),1),r-(ls->size+temp),val) );
		return re;
	}
	void Output()
	{
		if(this==nil)
			return ;
		ls->Output();
		printf("----------------    %d\n",val);
		rs->Output();
	}
}*root=nil;

Scapetree* Build_Tree(int a[],int l,int r)
{
	if(l>r) return nil;
	int i,mid=l+r>>1;
	Scapetree *lson=Build_Tree(a,l,mid-1);
	Scapetree *rson=Build_Tree(a,mid+1,r);
	Scapetree *re=new (lson,rson,a[mid],r-l+1) Scapetree;
	for(i=l;i<=r;i++)
		Insert(re->tree,a[i]);
	return re;
}

queue<Trie*> Trie :: bin;
queue<Scapetree*> Scapetree :: bin;
int Scapetree :: stack[M];
int Scapetree :: top;

int n,m,last_ans;
int a[M>>1];

void Initialize()
{
	null=new (0x0,0x0,0) Trie;
	null->son[0]=null->son[1]=null;
	nil=new (0x0,0x0,0,0) Scapetree;
	nil->ls=nil->rs=nil;
}

void Insert(int pos,int val)
{
	to_rebuild=0x0;
	Insert(root,pos,val);
	if(to_rebuild)
	{
		Scapetree::top=0;
		(*to_rebuild)->Decomposition();
		(*to_rebuild)=Build_Tree(Scapetree::stack,1,Scapetree::top);
	}
}

int Query(int l,int r)
{
	Kth_Getter getter;
	root->Get_2th(l,r,getter);
	int val=getter.Second();
	return root->Get_Max(l,r,val);
}

int main()
{
	#ifndef ONLINE_JUDGE
	freopen("3217.in","r",stdin);
	freopen("3217.out","w",stdout);
	#endif
	
	int i,x,y;
	char p[100];
	Initialize();
	cin>>n>>m;
	for(i=1;i<=n;i++)
		scanf("%d",&a[i]);
	root=Build_Tree(a,1,n);
	for(i=1;i<=m;i++)
	{
		scanf("%s",p);
		switch(p[0])
		{
			case 'I':
				scanf("%d%d",&x,&y);
				x=(x+last_ans)%(n++);
				y=(y+last_ans)%1048576;
				Insert(x,y);
				break;
			case 'D':
				scanf("%d",&x);
				x=(x+last_ans)%n+1;
				root->Delete(x);
				n--;
				break;
			case 'C':
				scanf("%d%d",&x,&y);
				x=(x+last_ans)%n+1;
				y=(y+last_ans)%1048576;
				root->Modify(x,y);
				break;
			case 'F':
				scanf("%d%d",&x,&y);
				x=(x+last_ans)%n+1;
				y=(y+last_ans)%n+1;
				if(x>y) swap(x,y);
				printf("%d\n", last_ans=Query(x,y) );
				break;
		}
		//root->Output();puts("");
	}
	return 0;
}