#include <bits/stdc++.h>
#include <iostream>
using namespace std;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
#define speed                   \
  ios_base::sync_with_stdio(0); \
  cin.tie(0);                   \
  cout.tie(0);
#define ll long long
#define pb push_back
#define mem1(a) memset(a, -1, sizeof(a))
#define mem0(a) memset(a, 0, sizeof(a))
#define endl "\n"
#define mod 1000000007
#define mod1 998244353
#define ff first
#define ss second
#define MAX 500005
#define N 300005
#define INF 1000000009
#define all(v) v.begin(), v.end()
#define sbit(a) __builtin_popcount(a)
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef pair<ll, ll> pll;
typedef pair<pll, ll> ppl;
typedef map<ll, ll> mpll;
typedef map<vector<ll>, ll> mpvl;
ll power(ll x, ll y, ll p)
{
    ll res = 1;

    x = x % p;

    if (x == 0)
        return 0;
    while (y > 0)
    {

        if (y & 1)
            res = (res * x) % p;

        y = y >> 1;
        x = (x * x) % p;
    }

    return res;
}
struct item {
    ll val, prior;
    ll sum, lazy, sz;
    bool rev;
    item * l, * r;

};
typedef item *pitem;
ll cnt(pitem t) {
    return t ? t->sz : 0;
}

void upd_cnt(pitem t) {
    if (t)
        t->sz = 1 + cnt(t->l) + cnt(t->r);
}
void lazy(pitem t) {
    if (!t || !t->lazy)return;
    t->val+=t->lazy;//operation of lazy
    t->sum+=t->lazy;
    //*sizeof(t);
    if (t->l)t->l->lazy+=t->lazy;//propagate lazy
    if (t->r)t->r->lazy+=t->lazy;
    t->lazy=0;
}
void reset(pitem t) {
    if (t)t->sum = t->val;//no need to reset lazy coz when we call this lazy would itself be propagated
}
void combine(pitem& t, pitem l, pitem r) {//combining two ranges of segtree
    if (!l || !r)return void(t = l?l:r);
    t->sum = l->sum + r->sum;
}
void operation(pitem t) {//operation of segtree
    if (!t)return;
    reset(t);//reset the value of current node assuming it now represents a single element of the array
    lazy(t->l);lazy(t->r);//imp:propagate lazy before combining t->l,t->r;
    combine(t, t->l, t);
    combine(t, t, t->r);
}
void merge(pitem & t, pitem l, pitem r) {


    lazy(l);lazy(r);
    if (!l || !r)
        t = l ? l : r;
    else if (l->prior > r->prior)
        merge(l->r, l->r, r), t = l;
    else
        merge(r->l, l, r->l), t = r;
    upd_cnt(t);
    operation(t);
}
void split(pitem t, pitem & l, pitem & r, ll key, ll add=0) {
    if (!t)
        return void(l = r = NULL);

    lazy(t);
    ll  cur_pos= add + cnt(t->l);
    if (cur_pos>=key)//element at pos goes to left subtree(l)
        split(t->l, l, t->l, key, add), r=t;
    else
        split(t->r, t->r, r, key, cur_pos+1), l=t;

    upd_cnt(t);
    operation(t);
}
ll range_query(pitem t, ll l, ll r) {//[l,r]
    pitem t1, t2, t3;
    split(t, t1, t2, l);
    split(t2, t2, t3, r-l+1);//note: r-l+1!!
    ll ans = t2->sum; //query ans
    merge(t, t1, t2);
    merge(t, t, t3);
    return ans;
}
void range_update(pitem t, ll l, ll r, ll val) {//[l,r]
    pitem t1, t2, t3;
    split(t, t1, t2, l);
    split(t2, t2, t3, r-l+1);//note: r-l+1!!
    t2->lazy+=val; //lazy_update
    merge(t, t1, t2);
    merge(t, t, t3);
}
void reverse(pitem t, ll l, ll r) {
    pitem t1, t2, t3;
    split(t, t1, t2, l);
    split(t2, t2, t3, r-l+1);
    t2->rev ^= true;
    merge(t, t1, t2);
    merge(t, t, t3);
}
pitem init(pitem &ret, ll val) {

    ret->prior=rand();ret->sz=1;
    ret->val=val;
    ret->sum=val;ret->lazy=0;
    ret->l=ret->r=NULL;
    return ret;
}

void solve()
{
    ll n, q;
    cin>>n>>q;
    pitem root=NULL;
    for (ll i =1;i<=n;i++)
    {
        pitem it=new item;
        init(it, 0);
        if (i==0) root=it;
        else merge(root, root, it);
    }

    while (q--)
    {

        ll y;
        cin>>y;


        if (y==0)
        {

            ll l, r, add;
            cin>>l>>r>>add;

            l--, r--;
            range_update(root, l, r, add);

        }
        else
        {
            ll l, r;
            cin>>l>>r;
            l--, r--;

            cout<<range_query(root, l, r)<<endl;
        }

    }




}
int main()
{

    speed;

    ll kk;
    kk = 1;
    cin >> kk;
    while (kk--)
    {
        srand(time(NULL));
        solve();
    }
    return 0;
}