void main(){
  import std.stdio, std.string, std.conv, std.algorithm;

  int n, q; rd(n, q);
  auto tree=new SquareRootDecomposition(n);
  while(q--){
    auto args=readln.split.to!(int[]);
    if(args[0]==0){
      tree.add(args[1]-1, args[2], args[3]);
    }else{
      writeln(tree.sum(args[1]-1, args[2]));
    }
  }
}

class SquareRootDecomposition{ // starry
  import std.algorithm;
  int D=1, nil=-1;
  long[] val, buc, star;
  this(int n){
    while(D*D<n) D++;
    val.length=D*D;
    buc.length=star.length=D;
  }

  void add(int ql, int qr, long x){
    foreach(k; 0..D){
      int l=k*D, r=(k+1)*D;
      if(r<=ql || qr<=l){
        // 
      }else if(ql<=l && r<=qr){
        star[k]+=x;
      }else{
        // push(k);
        foreach(i; max(l, ql)..min(r, qr)){
          buc[k]+=x;
          val[i]+=x;
        }
      }
    }
  }

  long sum(int ql, int qr){
    long ret=0;
    foreach(k; 0..D){
      int l=k*D, r=(k+1)*D;
      if(r<=ql || qr<=l){
        // 
      }else if(ql<=l && r<=qr){
        ret+=(buc[k]+star[k]*D);
      }else{
        int s=max(l, ql), t=min(r, qr);
        ret+=star[k]*(t-s);
        foreach(i; s..t) ret+=val[i];
      }
    }
    return ret;
  }
}

void rd(T...)(ref T x){
  import std.stdio, std.string, std.conv;
  auto l=readln.split;
  assert(l.length==x.length);
  foreach(i, ref e; x) e=l[i].to!(typeof(e));
}
