Problem:
RSQ and RAQ

Write a program which manipulates a sequence A = {a1, a2, . . . , an} with the following operations:

add(s, t, x): add x to as, as+1, ..., at.

getSum(s, t): report the sum of as, as+1, ..., at.

Note that the initial values of ai (i = 1, 2, . . . , n) are 0.

Input

n q
query1
query2
:
queryq

In the first line, n (the number of elements in A) and q (the number of queries) are given. Then, ith query queryi is given in the following format:

0 s t x

or

1 s t

The first digit represents the type of the query. '0' denotes add(s, t, x) and '1' denotes getSum(s, t).

Output

For each getSum operation, print the sum;

Constraints

1 ≤ n ≤ 100000

1 ≤ q ≤ 100000

1 ≤ s ≤ t ≤ n

0 ≤ x < 1000

Sample Input 1

3 5
0 1 2 1
0 2 3 2
0 3 3 3
1 1 2
1 2 3

Sample Output 1

4
8

Sample Input 2

4 3
1 1 4
0 1 4 1
1 1 4

Sample Output 2

0
4

Solution in Rust (judge verdict: Accepted)

use std::io;
use std::io::prelude::*;
use std::iter::repeat;

struct SumSegTree {
    n: usize,
    nodes: Vec<(u64, u64)>,
}

impl SumSegTree {
    fn new(n: usize) -> SumSegTree {
        let n = 1 << f64::log2(n as f64).ceil() as usize;
        SumSegTree {
            n,
            nodes: repeat((0, 0)).take(2 * n - 1).collect(),
        }
    }

    fn add(&mut self, s: usize, t: usize, x: u64, ni: usize, l: usize, r: usize) {
        self.eval(ni);
        if r <= s || t <= l {
            return;
        }
        if s <= l && r <= t {
            self.nodes[ni].1 = (r - l) as u64 * x;
            self.eval(ni);
            return;
        }
        let m = (l + r) / 2;
        self.add(s, t, x, 2 * ni + 1, l, m);
        self.add(s, t, x, 2 * ni + 2, m, r);
        self.nodes[ni].0 = self.nodes[2 * ni + 1].0 + self.nodes[2 * ni + 2].0;
    }

    fn eval(&mut self, ni: usize) -> u64 {
        self.nodes[ni].0 += self.nodes[ni].1;
        if ni < self.n - 1 {
            self.nodes[2 * ni + 1].1 += self.nodes[ni].1 / 2;
            self.nodes[2 * ni + 2].1 += self.nodes[ni].1 / 2;
        }
        self.nodes[ni].1 = 0;
        self.nodes[ni].0
    }

    fn get_sum(&mut self, s: usize, t: usize, ni: usize, l: usize, r: usize) -> u64 {
        self.eval(ni);
        if s <= l && r <= t {
            self.nodes[ni].0
        } else if r <= s || t <= l {
            0
        } else {
            self.get_sum(s, t, 2 * ni + 1, l, (l + r) / 2)
                + self.get_sum(s, t, 2 * ni + 2, (l + r) / 2, r)
        }
    }
}

fn main() {
    let stdin = io::stdin();
    let mut lines = stdin.lock().lines();

    let line0 = lines.next().unwrap().unwrap();
    let n = line0.split_whitespace().next().unwrap().parse().unwrap();

    let mut mst = SumSegTree::new(n);

    for l in lines.map(Result::unwrap) {
        let mut words = l.split_whitespace();
        let com = words.next().unwrap().parse().unwrap();
        let s: usize = words.next().unwrap().parse().unwrap();
        let t: usize = words.next().unwrap().parse().unwrap();
        let n = mst.n;
        match com {
            0 => {
                let x = words.next().unwrap().parse().unwrap();
                mst.add(s - 1, t, x, 0, 0, n);
            }
            1 => println!("{}", mst.get_sum(s - 1, t, 0, 0, n)),
            _ => (),
        }
    }
}