#include<bits/stdc++.h>
#define F(i,l,r) for(int i=l;i<r;++i)
#define Fe(i,l,r) for(int i=l;i<=r;++i)
#define Fer(i,l,r) for(int i=l;i>=r;--i)
#if 0
#define pr(...) fprintf(stderr,__VA_ARGS__)
#else
#define pr(...) void(0)
#endif

typedef long long i64;
const int maxn=1e6,maxm=1e6,N=maxn+10;

namespace IO{
const int BUF_SZ=1<<16;
char ib[BUF_SZ+1],*ip=ib+BUF_SZ;
void ipre(int n){
 int c=ib+BUF_SZ-ip;
 if(c<n){
  memcpy(ib,ip,c);
  ip=ib;
  fread(ib+c,1,BUF_SZ-c,stdin)[ib+c]=0;
 }
}
template<class T>
T read(T L,T R){
 ipre(100);
 T x=0,f=1;
 while(*ip<'0'||*ip>'9')if(*ip++=='-')f=-f;
 while(*ip>='0'&&*ip<='9')x=x*10+*ip++-'0';
 x*=f;
 if(!(L<=x&&x<=R)){
  std::cerr<<x<<" not in ["<<L<<","<<R<<"]\n";
  exit(1);
 }
 return x;
}
char ob[BUF_SZ+1],*op=ob;
void opre(int n){
 int c=ob+BUF_SZ-op;
 if(c<n){
  fwrite(ob,1,BUF_SZ-c,stdout);
  op=ob;
 }
}
template<class T>
void write(T x){
 opre(100);
 char ss[100],*sp=ss;
 if(x<T(0))x=-x,*op++='-';
 do *sp++=x%10+'0';while(x/=10);
 while(sp!=ss)*op++=*--sp;
}
template<class T>
void write(T x,char c){
 write(x);
 *op++=c;
}
struct __{
 __(){}
 ~__(){
  fwrite(ob,1,op-ob,stdout);
 }
}_;
};
using IO::read;
using IO::write;
const int MEM=1<<26;
char pool[MEM],*pool_p=pool;

template<class T>
void alloc(T *&p,int sz,bool init=1){
 //p=new T[sz]();
 //return;
 p=reinterpret_cast<T*>(pool_p);
 pool_p+=(sz*sizeof(T)+7)&~7;
 assert(pool_p<pool+MEM);
 if(init)F(i,0,sz)new(p+i)T();
}

template<class T>
struct Undo{
 T &x;
 T x0;
 Undo(T &x):x(x),x0(x){}
 ~Undo(){x=x0;}
};

#define alloc_scope Undo<char*> _##__LINE__(pool_p)
struct Void{
 char _[0];
 template<class T>
 friend void operator*=(T &,Void){}
 friend Void operator+(Void,Void){return Void();}
};

template<class D=Void,class M=Void>
struct MSegTree{
 struct Node{
  D d;
  M m;
  void app(const M &t){
   d*=t;
   m*=t;
  }
  void up(const Node &a,const Node &b){
   d=a.d+b.d;
   d*=m;
  }
 }*tr;
 int mx;
 int n;
 void in(int x){assert(1<=x&&x<=n);}
 void in(int l,int r){assert(1<=l&&l<=r&&r<=n);}
 void alloc(int n){
  for(mx=1;mx<n+2;mx<<=1);
  ::alloc(tr,mx+n+3);
  this->n=n;
 }
 void init(int n,D d0){
  alloc(n);
  Fe(i,1,n)tr[mx+i].d=d0;
  range_update(1,n);
 }
 template<class T>
 void init(int n,T *d0){
  alloc(n);
  Fe(i,1,n)tr[mx+i].d=d0[i];
  range_update(1,n);
 }
 Node &at(int x){
  in(x);
  return tr[mx+x];
 }
 D &operator[](int x){
  in(x);
  return tr[mx+x].d;
 }
 void range_update(int l,int r){
  in(l),in(r);
  l+=mx,r+=mx;
  for(l>>=1,r>>=1;l<r;l>>=1,r>>=1){
   Fe(x,l,r)up(x);
  }
  for(;l;l>>=1)up(l);
 }
 void up(int x){
  tr[x].up(tr[x*2],tr[x*2+1]);
 }
 void add(int x,const D &y){//M=Void
  in(x);
  for(x+=mx;x;x>>=1)tr[x].d=tr[x].d+y;;
 }
 void update(const M &t){
  tr[1].app(t);
 }
 template<class T>
 void update(int x,T y){
  in(x);
  for(tr[x+=mx].d=y;x>1;up(x>>=1));
 }
 void update(int l,int r,const M &t){
  in(l),in(r);
  for(l+=mx-1,r+=mx+1;l^r^1;up(l>>=1),up(r>>=1)){
   if(~l&1)tr[l+1].app(t);
   if(r&1)tr[r-1].app(t);
  }
  for(;l>1;up(l>>=1));
 }
 void update_prefix(int x,const M &t){
  in(x);
  for(x+=mx+1;x>1;up(x>>=1)){
   if(x&1)tr[x-1].app(t);
  }
 }
 void update_suffix(int x,const M &t){
  in(x);
  for(x+=mx-1;x>1;up(x>>=1)){
   if(~x&1)tr[x+1].app(t);
  }
 }
 D query(){
  return tr[1].d;
 }
 D query(int l,int r){
  in(l),in(r);
  assert(l<=r);
  D a1,a2;
  for(l+=mx-1,r+=mx+1;l^r^1;a1*=tr[l>>=1].m,a2*=tr[r>>=1].m){
   if(~l&1)a1=a1+tr[l+1].d;
   if(r&1)a2=tr[r-1].d+a2;
  }
  a1=a1+a2;
  for(;l>1;a1*=tr[l>>=1].m);
  return a1;
 }
 D query_prefix(int r){
  in(r);
  D a1;
  for(r+=mx+1;r>1;r>>=1,a1*=tr[r].m){
   if(r&1)a1=tr[r-1].d+a1;
  }
  return a1;
 }
 D query_suffix(int l){
  in(l);
  D a1;
  for(l+=mx-1;l>1;l>>=1,a1*=tr[l].m){
   if(~l&1)a1=a1+tr[l+1].d;
  }
  return a1;
 }
 void dn(int x){
  tr[x*2].app(tr[x].m);
  tr[x*2+1].app(tr[x].m);
  tr[x].m=M();
 }
 void dna(int x){
  in(x);
  x+=mx;
  for(int c=__builtin_ctz(mx);c>0;--c)dn(x>>c);
 }
 void dna(int l,int r){
  in(l,r);
  l+=mx,r+=mx;
  for(int c=__builtin_ctz(mx);c>0;--c){
   int L=l>>c,R=r>>c;
   Fe(i,L,R)dn(i);
  }
 }
 void dna(){
  F(i,1,mx){
   tr[i*2].app(tr[i].m);
   tr[i*2+1].app(tr[i].m);
   tr[i].m=M();
  }
 }
 template<class T>
 int bsearch_l(int x,T f){//M=Void
  in(x);
  for(x+=mx+1;;x>>=1){
   if(x&1){
    if(f(tr[x-1].d))break;
   }
  }
  for(--x;x<mx;){
   x<<=1;
   if(f(tr[x+1].d))++x;
  }
  x-=mx;
  return x+1;
 }
 template<class T>
 int bsearch_r(int x,T f){//M=Void
  in(x);
  for(x+=mx-1;;x>>=1){
   if(~x&1){
    if(f(tr[x+1].d))break;
   }
  }
  for(++x;x<mx;){
   x<<=1;
   if(!f(tr[x].d))++x;
  }
  x-=mx;
  return x-1;
 }
 template<class T>
 int find_lm(T f){
  int x=1;
  while(x<mx){
   dn(x);
   x<<=1;
   if(!f(tr[x].d))++x;
  }
  x-=mx;
  return x;
 }
};

template<class T>
struct BIT{
 T *a;
 int n;
 void alloc(int n0){
  n=n0;
  ::alloc(a,n+1);
 }
 void add(int x,T y){
  assert(1<=x&&x<=n);
  int _n=n;
  for(;x<=_n;x+=x&-x)a[x]+=y;
 }
 T sum(int x){
  assert(0<=x&&x<=n);
  T s=0;
  for(;x;x-=x&-x)s+=a[x];
  return s;
 }
 void dna(){
  Fe(i,1,n)a[i]+=a[i-(i&-i)];
 }
 T at(int x){
  assert(0<=x&&x<=n);
  return a[x];
 }
 void build(){
  Fe(i,1,n){
   int j=i+(i&-i);
   if(j<=n)a[j]+=a[i];
  }
 }
};
#define CMP(T,x) bool operator<(const T &w)const{return x<w.x;}
#define CMPL(T,x) [](const T &a,const T &b)->bool{return a.x<b.x;}
#define KEYL(T,x) [](const T &a){return a.x;}
template<class T,class F>
void rsort(T *d0,T *d1,int n,int v,F key){
 static int t[1<<20];
 F(i,0,v)t[i]=0;
 F(i,0,n)++t[key(d0[i])];
 int s=0;
 F(i,0,v){
  int a=t[i];
  t[i]=s;
  s+=a;
 }
 F(i,0,n)d1[t[key(d0[i])]++]=d0[i];
}

template<class T,class F>
void rsort2(T *d0,int n,F key){
 alloc_scope;
 T *d1;
 alloc(d1,n,0);
 rsort(d0,d1,n,2048,[key](const T &x){return key(x)&2047;});
 rsort(d1,d0,n,2048,[key](const T &x){return key(x)>>11;});
}
using std::max;
using std::min;

const int inf=1e9;

struct Pos{
 int x,y;
}ps[N],ds[N],ps0[N];
bool in(int x,int l,int r){return l<=x&&x<=r;}

struct XY{
 int x,y;
 XY(int x0=0,int y0=inf):x(x0),y(y0){}
};
XY operator+(XY a,XY b){
 return a.y<b.y?a:b;
}
MSegTree<XY> xyt;
BIT<int> xs0,ys0;
int cur[N];
int f1(int x1,int x2,int y1,int y2){
 if(x1>x2)return 0;
 XY xy=xyt.query(x1,x2);
 if(xy.y>y2)return 0;
 int id=cur[xy.x]++;
 xy.y=(ps0[id].x==ps0[id+1].x?ps0[id+1].y:inf);
 xyt.update(xy.x,xy);
 return id;
}
template<class T>
struct Sum{
 T x;
 Sum(T x0=0):x(x0){}
 operator T(){return x;}
 friend Sum operator+(Sum a,Sum b){return Sum(a.x+b.x);}
};
MSegTree<Sum<int>> xs,ys;
int sumclr(MSegTree<Sum<int>> &ws,int l,int r){
 if(l>r)return 0;
 int s0=ws.query(l,r);
 int s=s0;
 while(s0){
  int x=ws.bsearch_r(l,[](Sum<int> d){return d.x;})+1;
  s0-=ws[x];
  ws.add(x,-ws[x]);
  l=x+1;
 }
 return s;
}
struct Q{
 int x,y,id;
}qs[N];
int qp=0;
int ans[N];

struct MinI{
 int x;
 MinI(int x0=inf):x(x0){}
};
MinI operator+(MinI a,MinI b){return MinI(min(a.x,b.x));}
MSegTree<MinI> domt;
int main(){
 int n=read(1,maxn);
 int m=read(1,maxm);
 bool REV=0;
 Fe(i,1,n){
  ps[i].x=read(1,n);
  ps[i].y=read(1,n);
  if(REV)std::swap(ps[i].x,ps[i].y);
 }
 int n0=n;
 xs0.alloc(n);
 ys0.alloc(n);
 Fe(i,1,n){
  ++xs0.a[ps[i].x];
  ++ys0.a[ps[i].y];
  ps0[i]=ps[i];
 }
 xs0.build();
 ys0.build();
 rsort2(ps0+1,n,KEYL(Pos,y));
 rsort2(ps0+1,n,KEYL(Pos,x));
 xyt.alloc(n);
 Fe(i,1,n){
  Pos &p=ps0[i];
  if(p.x!=ps0[i-1].x){
   xyt[p.x]=XY(p.x,p.y);
   cur[p.x]=i;
  }
 }
 xyt.range_update(1,n);
 xs.alloc(n);
 ys.alloc(n);
 domt.alloc(n+2);
 domt[1]=1;
 domt[n+2]=1;
 domt.range_update(1,n+2);
 Fe(qi,1,m){
  int o=read(1,2);
  int x=read(1,n),y=read(1,n);
  int qx=read(1,n),qy=read(1,n);
  if(REV){
   o=3-o;
   std::swap(x,y);
   std::swap(qx,qy);
  }
  int mx=x+(o==1),my=y+(o==2);
  int dp=0;
  for(;;){
   int i=domt.find_lm([my](MinI d){return d.x<=my;});
   if(i>mx)break;
   ds[++dp]={i,domt[i].x};
   domt.update(i,inf);
  }
  if(dp){
   int x0=ds[1].x,y0=ds[dp].y;
   ds[0].y=my;
   ds[dp+1].x=mx;
   Fe(i,1,dp){
    int x1=ds[i].x,x2=ds[i+1].x-1;
    int y1=ds[i].y,y2=my-1,y3=ds[i-1].y-1;
    if(o==1&&x1<=x2){
     int s=sumclr(ys,y1,y3);
     if(s)xs.add(x1,s);
    }
    if(o==2&&y1<=y3){
     int s=sumclr(xs,x1,x2);
     if(s)ys.add(y1,s);
    }
    for(;;){
     int id=f1(x1,x2,y1,y2);
     if(!id)break;
     Pos &p=ps0[id]; 
     if(o==1)xs.add(p.x,1);
     else ys.add(p.y,1);
     --n0;
     xs0.add(p.x,-1);
     ys0.add(p.y,-1);
    }
   }
   if(x0<mx||x0==mx&&y0==my){
    domt.update(x0,my);
   }
   if(y0<my){
    domt.update(mx,y0);
   }
  }
  int y0=domt.query_prefix(qx).x;
  int ans0=0;
  if(y0<=qy){
   int x0=domt.find_lm([qy](MinI d){return d.x<=qy;});
   qs[qp++]={qx+1,qy+1,qi};
   ans0+=n;
   ans0-=n0-xs0.sum(qx);
   ans0-=n0-ys0.sum(qy);
   ans0-=xs.query().x-xs.query(x0,qx).x;
   ans0-=ys.query().x-ys.query(y0,qy).x;
   ans[qi]=ans0;
  }
 }
 rsort2(qs,qp,KEYL(Q,x));
 BIT<int> bit;
 bit.alloc(n+1);
 int pp=n;
 Fer(i,qp-1,0){
  Q &q=qs[i];
  for(;pp&&ps0[pp].x>=q.x;--pp)bit.add(n+1-ps0[pp].y,1);
  ans[q.id]+=bit.sum(n+1-q.y);
 }
 Fe(i,1,m)write(ans[i],'\n');
 return 0;
}