#ifdef zzafanti
#define _GLIBCXX_DEBUG
#endif // zzafanti

#include<bits/stdc++.h>

using namespace std;
using E=long long;
E sgn(E x){ return x<0?-1:1; }

struct segment{
  struct node{
    int l,r,fg=0;
    E x,lsum,y,val;

    node(){
      l=r=0,fg=0;
      x=y=val=lsum=0;
    }

  };

  /**
   * add ()
   * query ()
   */

  vector<node> tr,mem;

  void build(int u,int l,int r){
    mem[u].l=tr[u].l=l,mem[u].r=tr[u].r=r;
    if(l==r) return ;
    int mid=(l+r)>>1;
    build(u<<1,l,mid),build(u<<1|1,mid+1,r);
  }

  segment(int sz){
    mem=tr=vector<node>(sz*4+12);
    if(sz>=1) build(1,1,sz);
  }

  E calcu(int u,E k){ /// sum of the first k '('
    int l=tr[u].l,r=tr[u].r;
    if(l==r) return (tr[u].val)*k;
    int mid=(l+r)>>1;
    if(tr[u<<1].x-tr[u<<1|1].y>=k) return calcu(u<<1,k);
    return calcu(u<<1|1,k-max(0ll,(tr[u<<1].x-tr[u<<1|1].y)))+tr[u].lsum;
  }

  E calcu0(int u,E k){ /// sum of the first k '(' in mem
    if(mem[u].fg) return calcu(u,k);
    int l=mem[u].l,r=mem[u].r;
    if(l==r) return (mem[u].val)*k;
    int mid=(l+r)>>1;
    if(mem[u<<1].x-mem[u<<1|1].y>=k) return calcu0(u<<1,k);
    return calcu0(u<<1|1,k-max(0ll,(mem[u<<1].x-mem[u<<1|1].y)))+mem[u].lsum;
  }

  void maintain(int u){
    int ls=u<<1,rs=u<<1|1;
    if(tr[rs].y>=tr[ls].x){
      tr[u].y=tr[ls].y+tr[rs].y-tr[ls].x;
      tr[u].x=tr[rs].x;
      return ;
    }
    tr[u].lsum=calcu(u<<1,tr[ls].x-tr[rs].y);
    tr[u].x=tr[rs].x+tr[ls].x-tr[rs].y;
    tr[u].y=tr[ls].y;
  }

  void maintain0(int u){
    int ls=u<<1,rs=u<<1|1;
    if(mem[rs].y>=mem[ls].x){
      mem[u].y=mem[ls].y+mem[rs].y-mem[ls].x;
      mem[u].x=mem[rs].x;
      return ;
    }
    mem[u].lsum=calcu0(u<<1,mem[ls].x-mem[rs].y);
    mem[u].x=mem[rs].x+mem[ls].x-mem[rs].y;
    mem[u].y=mem[ls].y;
  }

  void add(int u,int pos,E dx,E ds,E dy){
    int l=tr[u].l,r=tr[u].r;
    if(l==r){
      tr[u].x+=dx;
      tr[u].val+=ds;
      tr[u].y+=dy;
      return ;
    }
    int mid=(l+r)>>1;
    if(pos<=mid) add(u<<1,pos,dx,ds,dy);
    else add(u<<1|1,pos,dx,ds,dy);
    maintain(u);
  }

  vector<int> stk;
  void query(int u,int R,E k){
    stk.emplace_back(u);
    int l=tr[u].l,r=tr[u].r;
    if(r<=R){
      mem[u]=tr[u];
      mem[u].fg=1;
      return ;
    }
    int mid=(l+r)>>1;
    if(R<=mid){
      query(u<<1,R,k);
      maintain0(u);
      return ;
    }
    query(u<<1,R,k);
    query(u<<1|1,R,k);
    maintain0(u);
    return ;
  }

  void reset(){
    while(stk.size()){
      mem[stk.back()]=node();
      mem[stk.back()].l=tr[stk.back()].l;
      mem[stk.back()].r=tr[stk.back()].r;
      stk.pop_back();
    }
  }

};

constexpr int N=100010;

struct querys{
  int op,when;
  E l,r;
  querys() { op=l=when=r=0; }
  querys(int Op=0,int wh=0,E L=0,E R=0) { op=Op,when=wh,l=L,r=R; }
  friend bool operator < (const querys &x,const querys &y){
    return x.when<y.when;
  }
};

vector<querys> oper[N];
int n,m;

int main(){

#ifdef zzafanti
  freopen("in.in","r",stdin);
#endif // zzafanti

  cin.tie(nullptr),cout.tie(nullptr)->sync_with_stdio(false);

  cin>>n>>m;
  vector<E> ans(m+1,-1);
  for(int i=1; i<=m; i++){
    int op,l,r;
    E x,y;
    cin>>op;
    if(op==1){
      cin>>l>>r>>x>>y;
      oper[l].emplace_back(querys(1,i,x,y));
      if(r<n) oper[r+1].emplace_back(querys(-1,i,x,y));
    }
    if(op==2){
      cin>>l>>r>>x;
      oper[l].emplace_back(querys(2,i,x,0));
      if(r<n) oper[r+1].emplace_back(querys(-2,i,x,0));
    }
    if(op==3){
      cin>>l>>x>>y;
      oper[l].emplace_back(querys(3,i,x,y));
    }
  }

  segment S(m);
  for(int i=1; i<=n; i++){
    sort(oper[i].begin(),oper[i].end());
    for(auto pt:oper[i]){
      if(abs(pt.op)==1){
        S.add(1,pt.when,pt.l*sgn(pt.op),sgn(pt.op)*pt.r,0);
      }
      if(abs(pt.op)==2){
        S.add(1,pt.when,0,0,pt.l*sgn(pt.op));
      }
      if(pt.op==3){
        S.query(1,pt.when,pt.r);
        ans[pt.when]=S.calcu0(1,pt.r);
        S.reset();
        S.query(1,pt.when,pt.l-1);
        ans[pt.when]-=S.calcu0(1,pt.l-1);
        S.reset();
      }
    }
  }

  for(int i=1; i<=m; i++){
    if(ans[i]!=-1){
      cout<<ans[i]<<'\n';
    }
  }

  return 0;
}