#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;

/*
struct SegmentTree1 {

    long long sum[1 << 18];
    long long lazy[1 << 18];
    int size;

    void init(int size) {
        this->size = 1 << (int)ceil(log2(size));
    }

    void propagate(int k) {
        if (lazy[k]) {
            sum[k] += lazy[k];
            if (k < size - 1) {
                lazy[k * 2 + 1] += lazy[k] / 2;
                lazy[k * 2 + 2] += lazy[k] / 2;
            }
            lazy[k] = 0;
        }
    }

    void add(int a, int b, int v, int k, int l, int r) {
        if (b <= l || r <= a) {
            propagate(k);
            return;
        }
        if (a <= l && r <= b) {
            lazy[k] += v * (r - l);
            propagate(k);
            return;
        }
        propagate(k);
        add(a, b, v, k * 2 + 1, l, (l + r) / 2);
        add(a, b, v, k * 2 + 2, (l + r) / 2, r);
        sum[k] = sum[k * 2 + 1] + sum[k * 2 + 2];
    }

    void add(int a, int b, int v) {
        add(a, b, v, 0, 0, size);
    }

    long long get(int a, int b, int k, int l, int r) {
        if (b <= l || r <= a) {
            return 0;
        }
        if (a <= l && r <= b) {
            propagate(k);
            return sum[k];
        }
        propagate(k);
        long long vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
        long long vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
        return vl + vr;
    }

    long long get(int a, int b) {
        return get(a, b, 0, 0, size);
    }
} st;
*/

struct SegmentTree2 {

    long long sum[1 << 18];
    long long lazy[1 << 18];
    int size;

    void init(int size) {
        this->size = 1 << (int)ceil(log2(size));
    }

    void propagate(int k) {
        if (lazy[k]) {
            if (k < size - 1) {
                lazy[k * 2 + 1] += lazy[k] / 2;
                sum[k * 2 + 1] += lazy[k] / 2;
                lazy[k * 2 + 2] += lazy[k] / 2;
                sum[k * 2 + 2] += lazy[k] / 2;
            }
            lazy[k] = 0;
        }
    }

    void add(int a, int b, int v, int k, int l, int r) {
        if (b <= l || r <= a) {
            return;
        }
        if (a <= l && r <= b) {
            lazy[k] += v * (r - l);
            sum[k] += v * (r - l);
            return;
        }
        propagate(k);
        add(a, b, v, k * 2 + 1, l, (l + r) / 2);
        add(a, b, v, k * 2 + 2, (l + r) / 2, r);
        sum[k] = sum[k * 2 + 1] + sum[k * 2 + 2];
    }

    void add(int a, int b, int v) {
        add(a, b, v, 0, 0, size);
    }

    long long get(int a, int b, int k, int l, int r) {
        if (b <= l || r <= a) {
            return 0;
        }
        if (a <= l && r <= b) {
            return sum[k];
        }
        propagate(k);
        long long vl = get(a, b, k * 2 + 1, l, (l + r) / 2);
        long long vr = get(a, b, k * 2 + 2, (l + r) / 2, r);
        return vl + vr;
    }

    long long get(int a, int b) {
        return get(a, b, 0, 0, size);
    }
} st;

int main() {
    int n, q;
    cin >> n >> q;
    st.init(n);
    while (q--) {
        int i, s, t, x;
        cin >> i >> s >> t;
        --s;
        if (i) {
            cout << st.get(s, t) << endl;
        } else {
            cin >> x;
            st.add(s, t, x);
        }
    }
    return 0;
}

Measured memory_bytes: 6424