#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;
    E x,lsum,y,val;

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

  };

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

  vector<node> tr,mem;

  void build(int u,int l,int r){
    tr[u].l=l,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;
  }

  void maintain(vector<node> &Tr,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 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(tr,u);
  }

  E query(int u,int R,E k){
    int l=tr[u].l,r=tr[u].r;
    if(r<=R){
      mem[u]=tr[u];
      return calcu(u,k);
    }
    int mid=(l+r)>>1;
    if(R<=mid){
      auto T=query(u<<1,R,k);
      maintain(mem,u);
      return T;
    }
    query(u<<1,R,k);
    query(u<<1|1,R,k);
    maintain(mem,u);
    return calcu(u,k);
  }

};

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){
        ans[pt.when]=S.query(1,pt.when,pt.r)-S.query(1,pt.when,pt.l-1);
      }
    }
  }

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

  return 0;
}