#include <bits/stdc++.h>
using namespace std;

#define QwQ01AwA return 0
#define ll long long
#define look_time cerr << 1.0 * clock() / CLOCKS_PER_SEC << '\n'
template <typename T> void ckmax(T &x, T y) {x = max(x, y);}
template <typename T> void ckmin(T &x, T y) {x = min(x, y);}


/* --------------- fast io --------------- */ // begin
namespace Fread {
const int SIZE = 1 << 21;
char buf[SIZE], *S, *T;
inline char getchar() {
    if (S == T) {
        T = (S = buf) + fread(buf, 1, SIZE, stdin);
        if (S == T) return '\n';
    }
    return *S++;
}
} // namespace Fread
namespace Fwrite {
const int SIZE = 1 << 21;
char buf[SIZE], *S = buf, *T = buf + SIZE;
inline void flush() {
    fwrite(buf, 1, S - buf, stdout);
    S = buf;
}
inline void putchar(char c) {
    *S++ = c;
    if (S == T) flush();
}
struct NTR {
    ~ NTR() { flush(); }
} ztr;
} // namespace Fwrite
#ifdef ONLINE_JUDGE
#define getchar Fread :: getchar
#define putchar Fwrite :: putchar
#endif
namespace Fastio {
struct Reader {
    template<typename T>
    Reader& operator >> (T& x) {
        char c = getchar();
        T f = 1;
        while (c < '0' || c > '9') {
            if (c == '-') f = -1;
            c = getchar();
        }
        x = 0;
        while (c >= '0' && c <= '9') {
            x = x * 10 + (c - '0');
            c = getchar();
        }
        x *= f;
        return *this;
    }
    Reader& operator >> (char& c) {
        c = getchar();
        while (c == ' ' || c == '\n') c = getchar();
        return *this;
    }
    Reader& operator >> (char* str) {
        int len = 0;
        char c = getchar();
        while (c == ' ' || c == '\n') c = getchar();
        while (c != ' ' && c != '\n' && c != '\r') { // \r\n in windows
            str[len++] = c;
            c = getchar();
        }
        str[len] = '\0';
        return *this;
    }
    Reader(){}
} cin;
const char endl = '\n';
struct Writer {
    template<typename T>
    Writer& operator << (T x) {
        if (x == 0) { putchar('0'); return *this; }
        if (x < 0) { putchar('-'); x = -x; }
        static int sta[45];
        int top = 0;
        while (x) { sta[++top] = x % 10; x /= 10; }
        while (top) { putchar(sta[top] + '0'); --top; }
        return *this;
    }
    Writer& operator << (char c) {
        putchar(c);
        return *this;
    }
    Writer& operator << (char* str) {
        int cur = 0;
        while (str[cur]) putchar(str[cur++]);
        return *this;
    }
    Writer& operator << (const char* str) {
        int cur = 0;
        while (str[cur]) putchar(str[cur++]);
        return *this;
    }
    Writer(){}
} cout;
} // namespace Fastio
#define cin Fastio :: cin
#define cout Fastio :: cout
#define endl Fastio :: endl
/* --------------- fast io --------------- */ // end

const int N = 1e6 + 5;
int n, m, lim;
struct Node {
    int x, y;
} p[N], cp[N];
struct Ask {
    int op, x, y, qx, qy, id;
} q[N], cq[N];
int ans[N];
vector <int> in[N];
struct {
    int t[N];
    inline void upd(int x, int w) {
        for (; x <= lim; x += x & (-x)) t[x] += w;
    }
    inline int query(int x) {
        int res = 0;
        for (; x; x -= x & (-x)) res += t[x];
        return res;
    }
    inline void clear() {memset(t, 0, sizeof(t));}
} t1, t2;
struct {
    int t[N];
    inline void upd(int x, int w) {
        for (; x; x -= x & (-x)) ckmin(t[x], w);
    }
    inline int query(int x) {
        int res = 1e9;
        for (; x <= lim; x += x & (-x)) ckmin(res, t[x]);
        return res;
    }
    inline void clear() {for (int i = 1; i <= lim; i++) t[i] = 1e9;}
} t3;
struct {
    int t[N];
    inline void upd(int x, int w) {
        for (; x; x -= x & (-x)) ckmax(t[x], w);
    }
    inline int query(int x) {
        int res = 0;
        for (; x <= lim; x += x & (-x)) ckmax(res, t[x]);
        return res;
    }
    inline void clear() {for (int i = 1; i <= lim; i++) t[i] = 0;}
} t4;

int cnt, rt;
mt19937 rng(time(0));
struct Tree {
    int ls, rs, siz, rnd, x, y, tagx, tagy;
} t[N];
#define ls(p) (t[p].ls)
#define rs(p) (t[p].rs)
inline int newnode(int x, int y) {
    int p = ++cnt;
    t[p].siz = 1;
    t[p].rnd = rng();
    t[p].x = x, t[p].y = y;
    return cnt;
}
inline void pushx(int p, int w) {t[p].x = t[p].tagx = w;}
inline void pushy(int p, int w) {t[p].y = t[p].tagy = w;}
inline void up(int p) {t[p].siz = t[ls(p)].siz + t[rs(p)].siz + 1;}
inline void down(int p) {
    if (t[p].tagx) pushx(ls(p), t[p].tagx), pushx(rs(p), t[p].tagx), t[p].tagx = 0;
    if (t[p].tagy) pushy(ls(p), t[p].tagy), pushy(rs(p), t[p].tagy), t[p].tagy = 0;
}
inline void splitx(int p, int k, int &x, int &y) {
    if (!p) return x = y = 0, void();
    down(p);
    if (t[p].x <= k) {
        x = p;
        splitx(rs(p), k, rs(p), y);
        up(p);
    } else {
        y = p;
        splitx(ls(p), k, x, ls(p));
        up(p);
    }
}
inline void splity(int p, int k, int &x, int &y) {
    if (!p) return x = y = 0, void();
    down(p);
    if (t[p].y >= k) {
        x = p;
        splity(rs(p), k, rs(p), y);
        up(p);
    } else {
        y = p;
        splity(ls(p), k, x, ls(p));
        up(p);
    }
}
inline void split(int p, int kx, int ky, int &x, int &y) {
    if (!p) return x = y = 0, void();
    down(p);
    if (t[p].x < kx || (t[p].x == kx && t[p].y > ky)) {
        x = p;
        split(rs(p), kx, ky, rs(p), y);
        up(p);
    } else {
        y = p;
        split(ls(p), kx, ky, x, ls(p));
        up(p);
    }
}
inline int merge(int u, int v) {
    if (!u || !v) return u + v;
    down(u), down(v);
    if (t[u].rnd < t[v].rnd) {
        rs(u) = merge(rs(u), v);
        up(u);
        return u;
    } else {
        ls(v) = merge(u, ls(v));
        up(v);
        return v;
    }
}
struct {
    int to, nxt;
} e[N];
int head[N], cc;
void add(int x, int w) {
    e[++cc] = {w, head[x]};
    head[x] = cc;
}
void clear() {
    cc = 0;
    for (int i = 1; i <= lim; i++) head[i] = 0;
}

signed main() {
    cin >> n >> m;
    lim = n;
    for (int i = 1; i <= n; i++) cin >> p[i].x >> p[i].y, cp[i] = p[i];
    for (int i = 1; i <= m; i++) cin >> q[i].op >> q[i].x >> q[i].y >> q[i].qx >> q[i].qy, q[i].id = i, cq[i] = q[i];
    for (int i = 1; i <= n; i++) add(cp[i].x, i);
    n = 0;
    for (int i = lim; i >= 1; i--) {
        for (int j = head[i]; j; j = e[j].nxt) {
            p[++n] = cp[e[j].to];
        }
    }
    clear();
    for (int i = 1; i <= m; i++) add(cq[i].qx, i);
    m = 0;
    for (int i = lim; i >= 1; i--) {
        for (int j = head[i]; j; j = e[j].nxt) {
            q[++m] = cq[e[j].to];
        }
    }
    for (int i = 1, j = 1; i <= m; i++) {
        while (j <= n && p[j].x > q[i].qx) t1.upd(p[j].y, 1), j++;
        ans[q[i].id] += j - 1 - t1.query(q[i].qy);
    }
    t1.clear();
    clear();
    for (int i = 1; i <= m; i++) add(cq[i].x, i);
    m = 0;
    for (int i = lim; i >= 1; i--) {
        for (int j = head[i]; j; j = e[j].nxt) {
            q[++m] = cq[e[j].to];
        }
    }
    t3.clear();
    for (int i = 1, j = 1; i <= n; i++) {
        t1.upd(p[i].x, 1);
        t2.upd(p[i].y, 1);
        while (j <= m && q[j].x >= p[i].x) t3.upd(q[j].y, q[j].id), j++;
        int tim = t3.query(p[i].y);
        if (tim <= m) in[tim].push_back(i);
    }
    for (int i = 1; i <= m; i++) {
        t4.upd(cq[i].x, cq[i].y);
        int r1, r2, r3;
        splitx(rt, cq[i].x, r1, r3);
        splity(r1, cq[i].y + 1, r1, r2);
        if (cq[i].op == 1) pushy(r2, cq[i].y);
        else pushx(r2, cq[i].x);
        for (auto id : in[i]) {
            t1.upd(p[id].x, -1), t2.upd(p[id].y, -1);
            if (cq[i].op == 1) p[id].y = cq[i].y;
            else p[id].x = cq[i].x;
            int X, Y;
            split(r2, p[id].x, p[id].y, X, Y);
            r2 = merge(merge(X, newnode(p[id].x, p[id].y)), Y);
        }
        rt = merge(merge(r1, r2), r3);
        if (t4.query(cq[i].qx + 1) > cq[i].qy) {
            ans[i] = 0;
        } else {
            ans[i] += t1.query(cq[i].qx) + t2.query(cq[i].qy);
            ans[i] += t[rt].siz;
            splitx(rt, cq[i].qx, r1, r3);
            splity(r1, cq[i].qy + 1, r1, r2);
            ans[i] += t[r2].siz - n;
            rt = merge(merge(r1, r2), r3);
        }
        cout << ans[i] << endl;
    }
    QwQ01AwA;
}