#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#include<bits/stdc++.h>
#define lc(x) (t[x].lc)
#define rc(x) (t[x].rc)
#define lowbit(x) (x&(-x))
using namespace std;
namespace io {
    const int __SIZE = (1 << 21) + 1;
    char ibuf[__SIZE], *iS, *iT, obuf[__SIZE], *oS = obuf, *oT = oS + __SIZE - 1, __c, qu[55]; int __f, qr, _eof;
    #define Gc() (iS == iT ? (iT = (iS = ibuf) + fread (ibuf, 1, __SIZE, stdin), (iS == iT ? EOF : *iS ++)) : *iS ++)
    inline void flush () { fwrite (obuf, 1, oS - obuf, stdout), oS = obuf; }
    inline void gc (char &x) { x = Gc(); }
    inline void pc (char x) { *oS ++ = x; if (oS == oT) flush (); }
    inline void pstr (const char *s) { int __len = strlen(s); for (__f = 0; __f < __len; ++__f) pc (s[__f]); }
    inline void gstr (char *s) { for(__c = Gc(); __c < 32 || __c > 126 || __c == ' ';)  __c = Gc();
        for(; __c > 31 && __c < 127 && __c != ' ' && __c != '\n' && __c != '\r'; ++s, __c = Gc()) *s = __c; *s = 0; }
    template <class I> inline bool gi (I &x) { _eof = 0;
        for (__f = 1, __c = Gc(); (__c < '0' || __c > '9') && !_eof; __c = Gc()) { if (__c == '-') __f = -1; _eof |= __c == EOF; }
        for (x = 0; __c <= '9' && __c >= '0' && !_eof; __c = Gc()) x = x * 10 + (__c & 15), _eof |= __c == EOF; x *= __f; return !_eof; }
    template <class I> inline void print (I x) { if (!x) pc ('0'); if (x < 0) pc ('-'), x = -x;
        while (x) qu[++ qr] = x % 10 + '0',  x /= 10; while (qr) pc (qu[qr --]); }
    struct Flusher_ {~Flusher_(){flush();}}io_flusher_;
} using io::pc; using io::gc; using io::pstr; using io::gstr; using io::gi; using io::print;

typedef long long ll;
typedef vector<int> vec; 
typedef array<int,2> pr;
const int MAXN = 1e6+10,INF = 1e9;
template<typename T>void tomin(T& x,T y){x = min(x,y);}
template<typename T>void tomax(T& x,T y){x = max(x,y);}
//
int n,m,x[MAXN],y[MAXN];
int o[MAXN],mx[MAXN],my[MAXN],qx[MAXN],qy[MAXN],ans[MAXN];

vec ap[MAXN]; int mt[MAXN],qt[MAXN];

struct BIT{
    int t[MAXN];
    void mdf(int x,int v){x=n-x+1;for(;x<=n;x+=lowbit(x))t[x] += v;}
    int qry(int x,int S=0){x=n-x+1;for(;x;x-=lowbit(x))S+=t[x]; return S;}
}tx,ty,tz;

namespace Pre{
    pr mdf[MAXN*3]; int tot;
    struct BIT{
        int t[MAXN];
        void init(){fill(t+1,t+1+n,INF);}
        void mdf(int x,int v){x=n-x+1;for(;x<=n;x+=lowbit(x))tomin(t[x],v);}
        int qry(int x,int S=INF){x=n-x+1;for(;x;x-=lowbit(x))tomin(S,t[x]);return S;}
    }bit;
    void solve(){
        for(int i=1;i<=n;i++)mdf[++tot] = {x[i],i};
        for(int i=1;i<=m;i++)mdf[++tot] = {mx[i],i+n},mdf[++tot] = {qx[i],i+n+m};
        sort(mdf+1,mdf+1+tot);
        bit.init();
        for(int r=tot,l;r>=1;r=l-1){
            l=r; while(l>1 && mdf[l-1][0] == mdf[l][0])l--;
            for(int j=l;j<=r;j++)if(mdf[j][1] > n && mdf[j][1] <= n+m){
                int id = mdf[j][1] - n;
                bit.mdf(my[id],id);
            }
            for(int j=l;j<=r;j++){
                int id = mdf[j][1];
                if(id <= n){
                    mt[id] = bit.qry(y[id]);
                    if(mt[id] != INF)ap[mt[id]].push_back(id);
                }else if(id > n+m)id -= n+m,qt[id] = bit.qry(qy[id]);
            }
        }
    }
}
namespace DS{
    mt19937 rnd(0);
    struct Node{
        int lc,rc,sz,key;
        int vx,vy,tx,ty;
        Node(){key = rnd(),tx = ty = -1;}
    }t[MAXN]; int tot,rt;
    void pu(int x){ t[x].sz = t[lc(x)].sz + 1 + t[rc(x)].sz; }
    void cx(int x,int v){if(!x)return; t[x].vx = t[x].tx = v;}
    void cy(int x,int v){if(!x)return; t[x].vy = t[x].ty = v;}
    void pd(int x){
        if(t[x].tx != -1)cx(lc(x),t[x].tx),cx(rc(x),t[x].tx),t[x].tx = -1;
        if(t[x].ty != -1)cy(lc(x),t[x].ty),cy(rc(x),t[x].ty),t[x].ty = -1;
    }
    int cn(int x,int y){
        tot++;
        t[tot].vx = x,t[tot].vy = y,t[tot].sz = 1;
        return tot;
    }
    //
    int merge(int x,int y){
        if(!x || !y)return x+y;
        pd(x); pd(y);
        if(t[x].key > t[y].key){
            rc(x) = merge(rc(x),y);
            return pu(x),x;
        }else{
            lc(y) = merge(x,lc(y));
            return pu(y),y;
        }
    }
    void split(int u,int limx,int limy,int& x,int& y){
        if(!u)return void(x=y=0);
        pd(u);
        if(t[u].vx <= limx && t[u].vy >= limy){
            x = u;
            split(rc(x),limx,limy,rc(x),y);
        }else{
            y = u;
            split(lc(y),limx,limy,x,lc(y));
        }
        pu(u);
    }
    //
    void insert(int x,int y){
        int a = 0,b = cn(x,y),c = 0;
        split(rt,x,y,a,c);
        rt = merge(merge(a,b),c);
    }    
    void preget(int x,int y,int& a,int& b,int& c){
        split(rt,INF,y+1,a,b);
        split(b,x,0,b,c);
    }
    int qry(int x,int y){
        int a = 0,b = 0,c = 0;
        preget(x,y,a,b,c);
        int ans = t[b].sz;
        rt = merge(merge(a,b),c);
        return ans;
    }
    void mdf(int o,int x,int y){
        int a = 0,b = 0,c = 0;
        preget(x,y,a,b,c); 
        if(o == 1)cy(b,y); else cx(b,x);
        rt = merge(merge(a,b),c);
    }
}

pr mdf[MAXN*2]; int tot;

int main(){
    gi(n); gi(m);
    for(int i=1;i<=n;i++)gi(x[i]),gi(y[i]),tx.mdf(x[i],1),ty.mdf(y[i],1);
    for(int i=1;i<=m;i++){
        gi(o[i]); gi(mx[i]); gi(my[i]); gi(qx[i]); gi(qy[i]);
    }
    Pre::solve();
    for(int i=1,A=n;i<=m;i++){  
        DS::mdf(o[i],mx[i],my[i]);

        for(auto id : ap[i]){
            tx.mdf(x[id],-1),ty.mdf(y[id],-1); A--; 
            if(o[i] == 1)DS::insert(x[id],my[i]);
            else DS::insert(mx[i],y[id]);
        }   
        //
        ans[i] = DS::qry(qx[i],qy[i]);
        if(qt[i] <= i)continue; 
        ans[i] += A; ans[i] -= tx.qry(qx[i]+1) + ty.qry(qy[i]+1);
        mdf[++tot] = {qx[i]+1,i+m};
    }
    for(int i=1;i<=n;i++)mdf[++tot] = {x[i],i};
    sort(mdf+1,mdf+1+tot);
    for(int r=tot,l;r>=1;r=l-1){
        l=r; while(l>1 && mdf[l-1][0] == mdf[l][0])l--;
        for(int j=l;j<=r;j++)if(mdf[j][1] <= n){
            int id = mdf[j][1];
            tz.mdf(y[id],1);
        }
        for(int j=l;j<=r;j++)if(mdf[j][1] > n){
            int id = mdf[j][1]-n;
            ans[id] += tz.qry(qy[id]+1);
        }
    }
    for(int i=1;i<=m;i++)print(ans[i]),pc('\n');
    return 0;
}