To the moon HDU

Background 
To The Moon is a independent game released in November 2011, it is a role-playing adventure game powered by RPG Maker. 
The premise of To The Moon is based around a technology that allows us to permanently reconstruct the memory on dying man. In this problem, we'll give you a chance, to implement the logic behind the scene. 

You‘ve been given N integers A _[1], A _[2],..., A _[N]. On these integers, you need to implement the following operations: 
1. C l r d: Adding a constant d for every {A _i | l <= i <= r}, and increase the time stamp by 1, this is the only operation that will cause the time stamp increase. 
2. Q l r: Querying the current sum of {A _i | l <= i <= r}. 
3. H l r t: Querying a history sum of {A _i | l <= i <= r} in time t. 
4. B t: Back to time t. And once you decide return to a past, you can never be access to a forward edition anymore. 
.. N, M ≤ 10 ⁵, |A _[i]| ≤ 10 ⁹, 1 ≤ l ≤ r ≤ N, |d| ≤ 10 ⁴ .. the system start from time 0, and the first modification is in time 1, t ≥ 0, and won't introduce you to a future state.

Input

n m 

A ₁ A ₂ ... A _n 
... (here following the m operations. )

Output

... (for each query, simply print the result. )

Sample Input

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

2 4
0 0
C 1 1 1
C 2 2 -1
Q 1 2
H 1 2 1

Sample Output

4
55
9
15

0
1

给出 n 个数，m次操作，操作一共分成 4 种
1、[l, r]内的值增加 d， 并且 time + 1
2、查询当前 time 时 [l, r]内的和
3、查询time = t 时 [l, r]内的和
4、把 time 退回到 t
然后对于2、3操作，输出对应的答案。
因为有4操作，所以要用主席树来保留每一个 time 的线段树。
对于区间修改操作，像线段树一样去更新，对于区间的sum，直接更新当前区间内的sum值，但是 update 的时候并不能保证 update 到的区间都被给出的区间所包含，所以需要用(min(r, pr) - max(l, pl) + 1)来确定有几个要更新的点。对于lazy，只有当 update 到的区间完全被给出的区间所包含的时候，才更新 lazy， 这样保证了 sum 不会多加， lazy 不会多标记。
对于区间查询操作，由于在之前更新的时候就已经把当前区间的 sum 求出来了，所以当某个区间完全被查询区间包含，只要直接加上这个区间的 sum 值就可以了。对于lazy，有 lazy 标记的区间，区间内的每个点都要加上 lazy 的值，所以如果我 query 到的区间有 lazy 标记，那么说明我这个区间内的每个点都应该多加 lazy ，给这个区间内需要加 lazy 的值的个数也是 (min(r, pr) - max(l, pl) + 1)

/*
          .
         ';;;;;.
        '!;;;;;;!;`
       '!;|&#@|;;;;!:
      `;;!&####@|;;;;!:
     .;;;!&@$$%|!;;;;;;!'.`:::::'.
     '!;;;;;;;;!$@###&|;;|%!;!$|;;;;|&&;.
     :!;;;;!$@&%|;;;;;;;;;|!::!!:::;!$%;!$%`    '!%&#########@$!:.
     ;!;;!!;;;;;|$$&@##$;;;::'''''::;;;;|&|%@$|;;;;;;;;;;;;;;;;!$;
     ;|;;;;;;;;;;;;;;;;;;!%@#####&!:::;!;;;;;;;;;;!&####@%!;;;;$%`
    `!!;;;;;;;;;;!|%%|!!;::;;|@##%|$|;;;;;;;;;;;;!|%$#####%;;;%&;
    :@###&!:;;!!||%%%%%|!;;;;;||;;;;||!$&&@@%;;;;;;;|$$##$;;;%@|
    ;|::;;;;;;;;;;;;|&&$|;;!$@&$!;;;;!;;;;;;;;;;;;;;;;!%|;;;%@%.
   `!!;;;;;;;!!!!;;;;;$@@@&&&&&@$!;!%|;;;;!||!;;;;;!|%%%!;;%@|.
%&&$!;;;;;!;;;;;;;;;;;|$&&&&&&&&&@@%!%%;!||!;;;;;;;;;;;;;$##!
!%;;;;;;!%!:;;;;;;;;;;!$&&&&&&&&&&@##&%|||;;;!!||!;;;;;;;$&:
':|@###%;:;;;;;;;;;;;;!%$&&&&&&@@$!;;;;;;;!!!;;;;;%&!;;|&%.
 !@|;;;;;;;;;;;;;;;;;;|%|$&&$%&&|;;;;;;;;;;;;!;;;;;!&@@&'
  .:%#&!;;;;;;;;;;;;;;!%|$$%%&@%;;;;;;;;;;;;;;;;;;;!&@:
  .%$;;;;;;;;;;;;;;;;;;|$$$$@&|;;;;;;;;;;;;;;;;;;;;%@%.
    !&!;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;|@#;
     `%$!;;;;;;;;;;;$@|;;;;;;;;;;;;;;;;;;;;;;;;!%$@#@|.
       .|@%!;;;;;;;;;!$&%||;;;;;;;;;;;;;;;;;!%$$$$$@#|.
           ;&$!;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;%#####|.
           |##$|!;;;;;;::'':;;;;;;;;;;;;;!%$$$@#@;
          ;@&|;;;;;;;::'''''':;;;;;;;|$&@###@|`
        .%##@|;;;;:::''''''''''::;!%&##$'
      `$##@$$@@&|!!;;;:'''''::::;;;;;|&#%.
    ;&@##&$%!;;;;;;::''''''''::;!|%$@#@&@@:
     .%@&$$|;;;;;;;;;;:'''':''''::;;;%@#@@#%.
    :@##@###@$$$$$|;;:'''':;;!!;;;;;;!$#@@#$;`
     `%@$$|;;;;;;;;:'''''''::;;;;|%$$|!!&###&'
     |##&%!;;;;;::''''''''''''::;;;;;;;!$@&:`!'
    :;!@$|;;;;;;;::''''''''''':;;;;;;;;!%&@$:                 !@#$'
      |##@@&%;;;;;::''''''''':;;;;;;;!%&@#@$%:              '%%!%&;
      |&%!;;;;;;;%$!:''''''':|%!;;;;;;;;|&@%||`            '%$|!%&;
      |@%!;;!!;;;||;:'''''':;%$!;;;;!%%%&#&%$&:           .|%;:!&%`
      !@&%;;;;;;;||;;;:''::;;%$!;;;;;;;|&@%;!$;          `%&%!!$&:
      '$$|;!!!!;;||;;;;;;;;;;%%;;;;;;;|@@|!$##;         !$!;:!$&:
       |#&|;;;;;;!||;;;;;;;;!%|;;;;!$##$;;;;|%'      `%$|%%;|&$'
        |&%!;;;;;;|%;;;;;;;;$$;;;;;;|&&|!|%&&;  .:%&$!;;;:!$@!
        `%#&%!!;;;;||;;;;;!$&|;;;!%%%@&!;;;!!;;;|%!;;%@$!%@!
        !&!;;;;;;;;;||;;%&!;;;;;;;;;%@&!;;!&$;;;|&%;;;%@%`
       '%|;;;;;;;;!!|$|%&%;;;;;;;;;;|&#&|!!||!!|%$@@|'
       .!%%&%'`|$;       :|$#%|@#&;%#%.
*/
#include <map>
#include <set>
#include <list>
#include <ctime>
#include <cmath>
#include <stack>
#include <queue>
#include <string>
#include <vector>
#include <cstdio>
#include <bitset>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define  lowbit(x)  x & (-x)
#define  mes(a, b)  memset(a, b, sizeof a)
#define  fi         first
#define  se         second
#define  pii        pair<int, int>
#define  INOPEN     freopen("in.txt", "r", stdin)
#define  OUTOPEN    freopen("out.txt", "w", stdout)

typedef unsigned long long int ull;
typedef long long int ll;
const int    maxn = 1e5 + 10;
const int    maxm = 1e5 + 10;
const ll     mod  = 1e9 + 7;
const ll     INF  = 1e18 + 100;
const int    inf  = 0x3f3f3f3f;
const double pi   = acos(-1.0);
const double eps  = 1e-8;
using namespace std;

int n, m;
int cas, tol, T;

struct Node{
    int l, r;
    ll sum, lazy;
} node[maxn * 40];
ll a[maxn];
int rt[maxn];

void init() {
    tol = 0;
    mes(a, 0);
    mes(rt, 0);
}

void pushup(int rt) {
    node[rt].sum = node[node[rt].l].sum + node[node[rt].r].sum;
}

void build(int l, int r, int &rt) {
    rt = ++tol;
    node[rt].sum = node[rt].lazy = 0;
    if(l == r) {
        node[rt].sum = a[l];
        return ;
    }
    int mid = (l + r) >> 1;
    build(l, mid, node[rt].l);
    build(mid+1, r, node[rt].r);
    pushup(rt);
}

void update(int l, int r, int &x, int y, int pl, int pr, ll val) {
    x = ++tol;
    node[x] = node[y];
    node[x].sum += 1ll * (min(r, pr) - max(l, pl) + 1) * val;
    if(pl <= l && r <= pr) {
        node[x].lazy += val;
        return ;
    }
    int mid = (l + r) >> 1;
    if(pl <= mid)
        update(l, mid, node[x].l, node[y].l, pl, pr, val);
    if(pr > mid)
        update(mid+1, r, node[x].r, node[y].r, pl, pr, val);
}

ll query(int l, int r, int pl, int pr, int rt) {
    if(pl <= l && r <= pr) {
        return node[rt].sum;
    }
    int mid = (l + r) >> 1;
    ll ans = 1ll * (min(r, pr) - max(l, pl) + 1) * node[rt].lazy;
    if(pl <= mid)
        ans += query(l, mid, pl, pr, node[rt].l);
    if(pr > mid)
        ans += query(mid+1, r, pl, pr, node[rt].r);
    return ans;
}

int main() {
    while(~scanf("%d%d", &n, &m)) {
        init();
        for(int i=1; i<=n; i++) {
            scanf("%lld", &a[i]);
        }
        T = 0;
        build(1, n, rt[T]);
        char s[10];
        while(m--) {
            scanf("%s", s+1);
            if(s[1] == 'C') {
                int l, r;
                ll d;
                scanf("%d%d%lld", &l, &r, &d);
                T++;
                update(1, n, rt[T], rt[T-1], l, r, d);
            } else if(s[1] == 'Q') {
                int l, r;
                scanf("%d%d", &l, &r);
                ll ans = query(1, n, l, r, rt[T]);
                printf("%lld
", ans);
            } else if(s[1] == 'H') {
                int l, r, t;
                scanf("%d%d%d", &l, &r, &t);
                ll ans = query(1, n, l, r, rt[t]);
                printf("%lld
", ans);
            } else if(s[1] == 'B'){
                int t;
                scanf("%d", &t);
                T = t;
            }
        }
    }
    return 0;
}