#pragma GCC optimize("Ofast","inline")
#include<bits/stdc++.h>
using namespace std;
const int N=2e6+200;

namespace IO {
#define iL (1 << 20)
char ibuf[iL], *iS = ibuf + iL, *iT = ibuf + iL;
#define gc() ((iS == iT) ? (iT = (iS = ibuf) + fread(ibuf, 1, iL, stdin), iS == iT ? EOF : *iS ++) : *iS ++)
template<class T> inline void read(T &x) {
  x = 0;int f = 0;char ch = gc();
  for (; !isdigit(ch); f |= ch == '-', ch = gc());
  for (; isdigit(ch); x = (x << 1) + (x << 3) + (ch ^ 48), ch = gc());
  x = (f == 1 ? ~ x + 1 : x);
}
template<class T, class... Args> inline void read(T &x, Args&... args) { read(x), read(args...); }
template<class T> inline void readch(T &x) { char ch = gc(); for (; !isalpha(ch); ch = gc()); x = ch; }
char Out[iL], *iter = Out;
#define flush() fwrite(Out, 1, iter - Out, stdout), iter = Out
template<class T> inline void write(T x, char ch = '\n') {
  T l, c[35];
  if (x < 0) *iter ++ = '-', x = ~ x + 1;
  for (l = 0; !l || x; c[l] = x % 10, l++, x /= 10);
  for (; l; -- l, *iter ++ = c[l] + '0');*iter ++ = ch;
  flush();
}
template<class T, class... Args> inline void write(T x, Args... args) { write(x, ' '), write(args...); }
} // IO
using namespace IO;

struct poi
{
    int x,y;

    friend bool operator<(poi a,poi b)
    {
        return a.y==b.y?a.x>b.x:a.y<b.y;
    }

    int in(poi t)
    {
        return (t.x>=x)&(t.y>=y);
    }
}a[N];

bool cmp(poi a,poi b)
{
    return a.y==b.y?a.x>=b.x:a.y<b.y;
}

struct node
{
    poi l,r,w,la;int opt,siz,rd;

    void mk(poi d,int o)
    {
        if(o&1)opt|=1,l.y=r.y=w.y=la.y=d.y;
        if(o&2)opt|=2,l.x=r.x=w.x=la.x=d.x;
    }
}t[N<<2];

int n,m,pos[N],vis[N],ans[N],mx[N],ch[N<<1][2],tot,ro,now,nw[N],c,mi[N];
int *g[N];

#define ls ch[x][0]
#define rs ch[x][1]

void up(int x)
{
    t[x].l=ls?t[ls].l:t[x].w;
    t[x].r=rs?t[rs].r:t[x].w;
    t[x].siz=t[ls].siz+t[rs].siz+1;
}

int make_new(poi w)
{
    int x=++tot;
    t[x]=(node){w,w,w,(poi){},0,1,rand()%10000000};
    return x;
}

void down(int x)
{
    if(!t[x].opt)return;
    if(ls)t[ls].mk(t[x].la,t[x].opt);
    if(rs)t[rs].mk(t[x].la,t[x].opt);
    t[x].opt=0;
}

void split(int x,poi k,int&a,int&b)
{
    if(!x)a=b=0;
    else
    {
        down(x);
        if(cmp(k,t[x].w))a=x,split(rs,k,rs,b);
        else b=x,split(ls,k,a,ls);
        up(x);
    }
}

int merge(int a,int b)
{
    if(!a||!b)return a+b;
    int w;
    if(t[a].rd<t[b].rd)ch[a][1]=merge(ch[a][1],b),up(a),w=a;
    else ch[b][0]=merge(a,ch[b][0]),up(b),w=b;
    return w;
}

void dfs(int x,poi d,int opt)
{
    if(!x)return;
    if(t[x].l.in(d)&&t[x].r.in(d))return t[x].mk(d,opt);
    if(t[x].r.y>d.y||t[x].l.x>d.x)return;
    down(x);dfs(ls,d,opt);dfs(rs,d,opt);
    if(t[x].w.in(d))
    {
        if(opt==1)t[x].w.y=d.y;
        else t[x].w.x=d.x;
    }
    up(x);
}

int find(int x,poi d)
{
    if(!x||t[x].r.y>d.y||t[x].l.x>d.x)return 0;
    if(t[x].l.in(d)&&t[x].r.in(d))return t[x].siz;
    down(x);return find(ls,d)+find(rs,d)+t[x].w.in(d);
}

void insert(int d,int x)
{
    for(int i=d;i<=n;i+=(i&(-i)))mi[i]=min(mi[i],x);
}

int Find(int d)
{
    int ans=1e9;
    for(int i=d;i;i-=(i&(-i)))ans=min(ans,mi[i]);
    return ans;
}

void rinsert(int x,int y)
{
    x=n-x+1;
    for(int i=x;i<=n;i+=(i&(-i)))mx[i]=max(mx[i],y);
}

int rfind(int x)
{
    x=n-x+1;int ans=0;if(x<0)return 0;
    for(int i=x;i;i-=(i&(-i)))ans=max(ans,mx[i]);
    return ans;
}

struct tree
{
    int p[N];

    void insert(int x,int d)
    {
        for(int i=x;i<=n;i+=(i&(-i)))p[i]+=d;
    }

    int find(int x)
    {
        int ans=0;
        for(int i=x;i;i-=(i&(-i)))ans+=p[i];
        return ans;
    }
}xx,yy,pp;

int tim;
vector<int>ad[N];

struct pask
{
    int opt,x,y,id;

    friend bool operator<(pask a,pask b)
    {
        return a.x==b.x?a.opt<b.opt:a.x>b.x;
    }
}rq[N];

vector<pair<int,int>>ask[N];

struct que
{
    int opt,x,y,X,Y;

    void in()
    {
        read(opt,x,y,X,Y);
    }
}ak[N];

int main()
{
    srand(19260817);
    // freopen("in","r",stdin);
    // freopen("out","w",stdout);
    read(n,m);now=n;
    for(int i=1;i<=n;i++)read(a[i].x,a[i].y),xx.insert(a[i].x,1),yy.insert(a[i].y,1);
    sort(a+1,a+1+n);
    for(int i=1;i<=n;i++)rq[i]=(pask){1,a[i].x,a[i].y,i};
    for(int i=1;i<=m;i++)ak[i].in(),rq[i+n]=(pask){0,ak[i].x,ak[i].y,i};
    for(int i=1;i<=n;i++)mi[i]=1e9+7;sort(rq+1,rq+1+n+m);
    for(int i=1;i<=n+m;i++)
    {
        if(rq[i].opt==0)insert(n-rq[i].y+1,rq[i].id);
        else
        {
            int w=Find(n-rq[i].y+1);
            if(w<=m)ad[w].push_back(rq[i].id);
        }
    }
    for(int i=1;i<=m;i++)
    {
        auto [opt,x,y,X,Y] = ak[i];
        rinsert(x,y);dfs(ro,(poi){x,y},opt);
        for(auto d:ad[i])
        {
            xx.insert(a[d].x,-1),yy.insert(a[d].y,-1);
            if(opt==1)a[d].y=y;else a[d].x=x;
            int x=0,y=0;now--;
            split(ro,a[d],x,y);
            ro=merge(merge(x,make_new(a[d])),y);
        }
        if(rfind(X+1)>Y)continue;
        ans[i]=find(ro,(poi){X,Y})+xx.find(X)+yy.find(Y)-now;
        ask[Y].push_back(make_pair(X,i));
    }
    for(int i=n,pos=n;i>=1;i--)
    {
        for(auto x:ask[i])ans[x.second]+=pp.find(n-x.first);
        while(pos&&a[pos].y==i)pp.insert(n-a[pos].x+1,1),pos--;
    }
    for(int i=1;i<=m;i++)write(ans[i]);
    cerr<<1.0*clock()/CLOCKS_PER_SEC<<'\n';
}