#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

// const int MAX_N = 1e5, MAX_Q = 1e5;
// const int DAT_SIZE = (1 << 18) - 1;

// //入力
// int N, Q;
// int A[MAX_N];
// char T[MAX_Q];
// int L[MAX_Q], R[MAX_Q], X[MAX_Q];

// //セグメント木
// ll DATA[DAT_SIZE], DATB[DAT_SIZE];

// /*
// セグメント木を書くときは、範囲内か範囲外か判定して、
// 一部繋がっているなら再帰でさらに区間を分けると良い 
// */

// // [a,b)にxを加算する
// // kは節点の番号で、区間[l, r)に対応する
// void add(int a, int b, int x, int k, int l, int r){
//     if(a <= l && r <= b){
//         DATA[k] += x;
//     }
//     else if(l < b && a < r){
//         DATB[k] += (min(b, r) - max(a, l)) * x;
//         add(a, b, x, k * 2 + 1, l, (l + r) / 2);
//         add(a, b, x, k * 2 + 2, (l + r) / 2, r);
//     }
// }

// // [a,b)の和を計算する
// // kは節点の番号で、区間[l, r)に対応する
// ll sum(int a, int b, int k, int l, int r){
//     if(b <= l || r <= a){
//         return 0;
//     }
//     else if (a <= l && r <= b){
//         return DATA[k] * (r - l) + DATB[k];
//     }
//     else{
//         ll res = (min(b, r) - max(a, l)) * DATA[k];
//         res += sum(a, b, k * 2 + 1, l, (l + r) / 2);
//         res += sum(a, b, k * 2 + 2, (l + r) / 2, r);
//         return res;
//     }
// }

// void solve(){
//     for(int i = 0; i < N; i++){
//         add(i, i + 1, A[i], 0, 0, N);
//     }
    
//     for(int i = 0; i < Q; i++){
//         if(T[i] == 'C'){
//             add(L[i], R[i] + 1, X[i], 0, 0, N);
//         }
//         else{
//             printf("%lld\n", sum(L[i], R[i] + 1, 0, 0, N));
//         }
//     }
// }
struct LazySegmentTree{
    private:
        int n;
        vector<ll> node, lazy;

    public:
        LazySegmentTree(vector<ll> v){
            int sz = (int)v.size();
            n = 1; while(n < sz) n *= 2;
            node.resize(2 * n - 1);
            lazy.resize(2 * n - 1, 0);

            for(int i = 0; i < sz; i++) node[i + n - 1] = v[i];
            for(int i = n - 2; i >= 0; i--) node[i] = node[i * 2 + 1] + node[i * 2 + 2];
        }
        void eval(int k, int l, int r){
            if(lazy[k] != 0){
                node[k] += lazy[k];
                if(r - l > 1){
                    lazy[2*k + 1] += lazy[k] / 2;
                    lazy[2*k + 2] += lazy[k] / 2;
                }
                lazy[k] = 0;
            }
        }

        void add(int a, int b, ll x, int k = 0, int l = 0, int r = -1){
            if(r < 0) r = n;
            eval(k, l, r);
            if(b <= l || r <= a) return;
            if(a <= l && r <= b){
                lazy[k] += (r - l) * x;
                eval(k, l, r);
            }
            else{
                add(a, b, x, 2 * k + 1, l, (l + r) / 2);
                add(a, b, x, 2 * k + 2, (l + r)/ 2, r);
                node[k] = node[2 * k + 1] + node[2 * k + 2];
            }
        }

        ll getsum(int a, int b, int k = 0, int l = 0, int r = -1){
            if(r < 0) r = n;
            eval(k, l, r);
            if(b <= l || r <= a) return 0;
            if(a <= l && r <= b) return node[k];
            ll vl = getsum(a, b, 2 * k + 1, l, (l + r) /2);
            ll vr = getsum(a, b, 2 * k + 2,(l + r)/ 2, r);
            return vl + vr;
        }
};


int main(){
    int n, q; cin >> n >> q;
    LazySegmentTree seg( vector<ll>(n, 0));
    while(q--){
        int A; cin >> A;
        if(A == 0){
            int s, t, x; cin >> s >> t >> x; s--, t--;
            seg.add(s, t + 1, x);
        }else{
            int s, t; cin >> s >> t; s--, t--;
            cout << seg.getsum(s, t + 1) << endl; 
        }
    }

    return 0;
}


Measured memory_bytes: 7600