帮我调平衡树！虽然有点标题党，但是还是希望大佬们帮忙orz

现在看最大子段和寄了（没过样例），成废物了

#include<bits/stdc++.h>
using namespace std;
#define int long long
#define inf 0x3f3f3f3f3f3f3f3f
// #define endl '\n'
#define debug cout << "114514" << endl
int n,q;
struct Treap{
    int ls,rs,sum,tag1,tag2,val,key,lmax,rmax,mmax,siz;
}t[500010];
mt19937 rnd(998244353);
int tot,root;
int a[500010];
int delnode[500010],top;
int new_node(int x)
{
    int node;
    if(top)
    {
        node=delnode[top];
        top--;
    }else{
        node=++tot;
    }
    t[node].ls=t[node].rs=0;
    t[node].sum=t[node].val=x;
    t[node].tag1=inf;
    t[node].tag2=0;
    t[node].key=rnd();
    t[node].lmax=t[node].rmax=t[node].mmax=x;
    t[node].siz=1;
    return node;
}
void pu(int x)
{
    t[0].val=t[0].sum=t[0].siz=0;
    t[x].siz=t[t[x].ls].siz+t[t[x].rs].siz+1;
    t[x].sum=t[x].val;
    t[x].lmax=t[x].rmax=t[x].mmax=t[x].val;
    if(t[x].ls)
    {
        t[x].lmax=max(t[t[x].ls].lmax,t[t[x].ls].sum+t[x].val);
        t[x].rmax=max(t[x].val,t[x].val+t[t[x].ls].rmax);
        t[x].mmax=max(max(t[t[x].ls].rmax+t[x].val,t[t[x].ls].mmax),t[x].val);
        t[x].mmax=max(max(t[x].lmax,t[x].rmax),t[x].mmax);
        t[x].sum+=t[t[x].ls].sum;
    }
    if(t[x].rs)
    {
        t[x].lmax=max(t[x].lmax,t[x].sum+t[t[x].rs].lmax);
        t[x].rmax=max(t[t[x].rs].rmax,t[t[x].rs].sum+t[x].rmax);
        t[x].mmax=max(max(t[x].mmax,t[x].rmax+t[t[x].rs].lmax),t[t[x].rs].mmax);
        t[x].mmax=max(max(t[x].lmax,t[x].rmax),t[x].mmax);
        t[x].sum+=t[t[x].rs].sum;
    }
}
void pd(int x)
{
    if(t[x].tag1!=inf)
    {
        t[t[x].ls].val=t[t[x].rs].val=t[x].tag1;
        t[t[x].ls].sum=t[t[x].ls].siz*t[x].tag1;
        t[t[x].rs].sum=t[t[x].rs].siz*t[x].tag1;
        t[t[x].ls].tag1=t[t[x].rs].tag1=t[x].tag1;
        t[x].tag1=inf;
    }
    if(t[x].tag2)
    {
        swap(t[x].ls,t[x].rs);
        swap(t[x].lmax,t[x].rmax);
        t[x].tag2=0;
    }
}
void split_k(int x,int val,int &l,int &r)
{
    if(!x)
    {
        l=r=0;
        return;
    }
    if(t[t[x].ls].siz+1<=val)
    {
        l=x;
        split_k(t[x].rs,val-t[t[x].ls].siz-1,t[x].rs,r);
        pu(x);
    }else{
        r=x;
        split_k(t[x].ls,val,l,t[x].ls);
        pu(x);
    }
}
int merge(int l,int r)
{
    if(!l||!r)
    {
        return l+r;
    }
    if(t[l].key<t[r].key)
    {
        pd(l);
        t[l].rs=merge(t[l].rs,r);
        pu(l);
        return l;
    }else{
        pd(r);
        t[r].ls=merge(l,t[r].ls);
        pu(r);
        return r;
    }
}
int new_tree(int l,int r)
{
    if(l==r)
    {
        return new_node(a[l]);
    }
    int mid=(l+r)/2;
    return merge(new_tree(l,mid),new_tree(mid+1,r));
}
void delt(int x)
{
    if(!x)
    {
        return;
    }
    delnode[++top]=x;
    delt(t[x].ls);
    delt(t[x].rs);
}
void print(int x)
{
    if(!x)
    {
        return;
    }
    print(t[x].ls);
    cout << t[x].val << " " ;
    print(t[x].rs);
}
signed main()
{
    ios::sync_with_stdio(false);
    cin.tie(0),cout.tie(0);
	cin >> n >> q;
    for ( int i = 1 ; i <= n ; i++ )
    {
        cin >> a[i];
    }
    root=new_tree(1,n);
    // print(root);
    cout << endl;
    while(q--)
    {
        string op;
        int L,R,M;
        cin >> op;
        if(op=="GET-SUM")
        {
            int l,r;
            cin >> l >> r;
            l--;
            r=r+l;
            // cout << l << ' ' << r << endl;
            split_k(root,r,L,R);
            // print(L);
            // cout << endl;
            // print(R);
            // cout << endl;
            split_k(L,l,L,M);
            // print(M);
            // cout << endl;
            cout << t[M].sum << endl;
            root=merge(merge(L,M),R);
        }else if(op=="INSERT")
        {
            int p;
            cin >> p;
            split_k(root,p,L,R);
            cin >> n;
            for ( int i = 1 ; i <= n ; i++ )
            {
                cin >> a[i];
            }
            root=merge(merge(L,new_tree(1,n)),R);
        }else if(op=="DELETE")
        {
            int l,r;
            cin >> l >> r;
            l--;
            r=l+r;
            split_k(root,r,L,R);
            split_k(L,l,L,M);
            delt(M);
            root=merge(L,R);
        }else if(op=="MAKE-SAME")
        {
            int l,r,p;
            cin >> l >> r >> p;
            l--;
            r=l+r;
            split_k(root,r,L,R);
            split_k(L,l,L,M);
            t[M].val=p;
            t[M].tag1=p;
            t[M].sum=t[M].siz*p;
            if(p<0)
            {
                t[M].lmax=t[M].rmax=t[M].mmax=p;
            }else{
                t[M].lmax=t[M].rmax=t[M].mmax=t[M].sum;
            }
            root=merge(merge(L,M),R);
        }else if(op=="REVERSE")
        {
            int l,r;
            cin >> l >> r;
            l--;
            r=l+r;
            split_k(root,r,L,R);
            split_k(L,l,L,M);
            t[M].tag2=1;
            root=merge(merge(L,M),R);
        }else{
            cout << t[root].mmax << endl;
        }
    }
    return 0;
}