很荒谬啊，很抽象啊，很神秘啊，为什么会跑不完呢，为什么呢。

#include <bits/stdc++.h>
using namespace std;
#define ll long long 
#define rl register ll
#define wl putchar('\n')
#define ws putchar(' ')

template <class T> inline void read(T &res)
{
    char ch = getchar(); bool f = 0; res = 0;
    for(; !isdigit(ch); ch = getchar()) f |= ch == '-';
    for(; isdigit(ch); ch = getchar()) res = (res << 1) + (res << 3) + (ch ^ 48);
    res = f ? ~res + 1 : res;
}

template <class T> inline void waw(T x)
{
    if(x > 9) waw(x / 10);
    putchar(x % 10 ^ 48);
}

template <class T> inline void ww(T x)
{
    if(x < 0) x = ~x + 1, putchar('-');
    waw(x);
}

const ll N = 2e5 + 10, INF = 1e16;

ll n, w[N], root, idx, m;

struct tree
{
    ll s[2], key, fa;
    ll size, ms, ls, sum, rs;
    
    inline void init(ll v, ll p)
    {
        fa = p, key = v, sum = v;
        ls = rs = max(v, 0ll), size = 1;
        s[0] = s[1] = 0;
    }
}tr[N];

#define fa(x) tr[(x)].fa
#define ls(x) tr[(x)].s[0]
#define rs(x) tr[(x)].s[1]

inline bool get(ll x) { return x == rs(fa(x)); }
// inline void clear(ll u) { ls(u) = rs(u) = fa(u) = tr[u].size = tr[u].key = tr[u].ms = tr[u].ls = tr[u].rs = 0; }

inline void pushup(ll u)
{
    auto &rt = tr[u], &l = tr[ls(u)], &r = tr[rs(u)];

    rt.size = l.size + r.size + 1;
    rt.sum = l.sum + r.sum + rt.key;
    rt.ls = max(l.ls, l.sum + rt.key + r.ls);
    rt.rs = max(r.rs, r.sum + rt.key + l.rs);
    rt.ms = max(l.rs + rt.key + r.ls, max(l.ms, r.ms));
}

inline void rotate(ll x)
{
    ll y = fa(x), z = fa(y); bool c = get(x);
    fa(tr[x].s[c ^ 1] ) = y, tr[y].s[c] = tr[x].s[c ^ 1];
    tr[x].s[c ^ 1] = y, fa(y) = x, fa(x) = z;
    if(z) tr[z].s[y == rs(z)] = x;
    root = x;
}

inline void splay(ll x, ll y)
{
    for(rl f = fa(x); f = fa(x), f != y; rotate(x))
        if(fa(f) != y) rotate(get(x) == get(f) ? f : x);
    if(!y) root = x;
}

inline ll kth(ll rk)
{
    ll u = root;
    while(u)
    {
        ll sz = tr[ls(u)].size + 1;
        if(sz > rk) u = ls(u);
        else if(sz == rk) return u;
        else rk -= sz, u = rs(u); 
    }

    return -1;
}

inline void insert(ll p, ll x)
{
    ll l = kth(p), r = kth(p + 1);
    splay(l, 0), splay(r, l);
    ll u = ++ idx; tr[u].init(x, r); ls(r) = u;
    pushup(r), pushup(l);
}

inline void dele(ll p)
{
    ll l = kth(p), r = kth(p + 2);
    splay(l, 0), splay(r, l); ls(r) = 0;
    pushup(r), pushup(l);
}

inline ll query(ll l, ll r)
{
    l = kth(l), r = kth(r + 2);
    splay(l, 0), splay(r, l);
    return tr[ls(r)].ms;
}

inline void update(ll p, ll x)
{
    ll pos = kth(p + 1);
    splay(pos, 0);
    tr[pos].key = x;
    pushup(pos);
}

inline ll build(ll l, ll r, ll p)
{
    ll mid = l + r >> 1, u = ++ idx;
    tr[u].init(w[mid], p);
    if(l < mid) ls(u) = build(l, mid - 1, u);
    if(mid < r) rs(u) = build(mid + 1, r, u);
    pushup(u); return u;
}

inline void print(ll u)
{
    if(ls(u)) print(ls(u));
    if(tr[u].key) printf(" u : %lld key : %lld\n", u, tr[u].key);
    if(rs(u)) print(rs(u));
}

int main()
{
    freopen("1.in", "r", stdin), freopen("1.out", "w", stdout);
    
    read(n); 

    w[0] = w[n + 1] = -INF;

    for(rl i=1; i <= n; ++ i)  read(w[i]);

    root = build(0, n + 1, 0);

    // print(root);

    read(m);

    while(m -- )
    {
        string op; ll p, x;
        cin >> op, read(p);

        // ww(m), wl;

        switch(op[0])
        {
            case 'I' : { read(x); insert(p, x); break; }
            case 'D' : { dele(p); break; }
            case 'R' : { read(x); update(p, x); break;}
            case 'Q' : { read(x); ww(query(p, x)), wl; break; }
        }
        // print(root);
    }
    return 0;
}