//This code is $$$O(n\sqrt{n})$$$
//TODO test how it compares to $$$O(n\sqrt{n\log{N}})$$$ in practice
#include <cstdio>
#include <stdint.h>
#include <vector>
#include <algorithm>
#include <cassert>

const int MAXN=100005;

struct UpperNode{
  std::vector<int> data;
  std::vector<int> ls;
  int shift;
}upper[MAXN];

std::pair<int,int> lower[MAXN];
int as[MAXN];

void pull(int w){
  auto& left=upper[w*2+1];
  auto& right=upper[w*2+2];
  upper[w].data.clear();
  upper[w].ls.clear();
  upper[w].ls.push_back(0);
  //sample every 4th element from children and merge
  //i and j can go past end
  //this ensures i+j=4*index so only ls is needed
  int i=0,j=0;
  while(i<left.data.size()||j<right.data.size()){
    if(j>=right.data.size()||(i<left.data.size()&&left.data[i]+left.shift<right.data[j]+right.shift)){
      upper[w].data.push_back(left.data[i]+left.shift);
      i+=4;
    }else{
      upper[w].data.push_back(right.data[j]+right.shift);
      j+=4;
    }
    upper[w].ls.push_back(i);
  }
}

void build(int w,int len,int L,int R){
  if(R-L<=len){
    for(int i=L;i<R;i++){
      lower[i]={as[i],i};
    }
    std::sort(lower+L,lower+R);
    for(int i=L;i<R;i++){
      upper[w].data.push_back(lower[i].first);
    }
  }else{
    int M=(L+R)/2;
    build(w*2+1,len*2,L,M);
    build(w*2+2,len*2,M,R);
    upper[w].shift=0;
    pull(w);
  }
}

void update(int w,int len,int L,int R,int a,int b,int X){
  if(b<=L||a>=R) return;
  if(a<=L&&b>=R){
    upper[w].shift+=X;
    return;
  }
  if(R-L<=len){
    //use partition/merge
    //TODO test if STL stable_partition,inplace_merge is faster
    //or if copying to temporary array is faster
    auto mid=std::stable_partition(lower+L,lower+R,[a,b](std::pair<int,int> elem){return elem.second>=a&&elem.second<b;});
    for(auto it=lower+L;it!=mid;it++){
      it->first+=X;
    }
    std::inplace_merge(lower+L,mid,lower+R);
    
    for(int i=L;i<R;i++){
      upper[w].data[i-L]=lower[i].first;
    }
  }else{
    int M=(L+R)/2;
    update(w*2+1,len*2,L,M,a,b,X);
    update(w*2+2,len*2,M,R,a,b,X);
    pull(w);
  }
}

//count number in [a,b) that are <=X
int query(int w,int len,int L,int R,int a,int b,int X,int index){
  if(b<=L||a>=R) return 0;
  X-=upper[w].shift;
  while(index>upper[w].data.size()||(index>0&&upper[w].data[index-1]>X)){
    index--;
  }
  //upper[w].data[index] is first greater than X
  if(R-L<=len){
    if(a<=L&&b>=R){
      return index;
    }else{
      int cnt=0;
      for(int i=L;i<R;i++){
	if(lower[i].second>=a&&lower[i].second<b&&lower[i].first<=X){
	  cnt++;
	}
      }
      return cnt;
    }
  }else{
    int M=(L+R)/2;
    return query(w*2+1,len*2,L,M,a,b,X,upper[w].ls[index])+
      query(w*2+2,len*2,M,R,a,b,X,index*4-upper[w].ls[index]);
  }
}

int main(){
  int N,Q;
  scanf("%d %d",&N,&Q);
  build(0,1,0,N);
  while(Q--){
    int T,L,R,X;
    scanf("%d %d %d %d",&T,&L,&R,&X);
    if(T==1){
      update(0,1,0,N,L,R,X);
    }else{
      int cnt=query(0,1,0,N,L,R,X,upper[0].data.size());
      printf("%d\n",cnt);
    }
  }
}