#include <stdio.h>

#define dbg
#define clk

#ifdef dbg
#define pr printf
#else
#define pr
#endif

#ifdef clk
#include <time.h>

clock_t _c[4];

#define millis(c) c // ((c / CLOCKS_PER_SEC) * 1000.0)
#define clki() for (int i = 0; i < 4; i++) _c[i] = 0
#define clk0(i) (_c[i] = clock())
#define clk1(i) (_c[i+1] += (clock() - _c[i]))
#define clkp(s, i) pr("%s: %10dms", s, millis(_c[i+1]))
#else
#define clki()
#define clk0(i)
#define clk1(i)
#define clkp(s, i)
#endif

#define sz 50000

int rnd() {
    static int s = 7654321;

    return s = (s * 2 + 3) % 9876543;
}

int max(int x, int y) { return x > y ? x : y; }

class dt {
public:
    int x, y;

    bool operator<(dt& d) { return x < d.x; }
    bool operator>(dt& d) { return x > d.x; }
    bool operator<=(dt& d) { return x <= d.x; }
    operator int() { return x; }

    void dmp() {
#ifdef dbg
        pr("%d,%d,", x, y);
#endif
    }
} dt[sz];

template <typename K>
class tr {
public:
    K* k;
    int p, c;
    tr *l, *r;

    tr(K* k = NULL) { init(k); }

    tr& init(K* k = NULL) {
        this->k = k;
        p = rnd();
        c = 1;
        l = r = NULL;

        return *this;
    }

    static int cnt(tr* t) { return t ? t->c : 0; }

    tr* updt() { c = 1 + cnt(l) + cnt(r); return this; }

    tr& splt(tr* t) {
        if (t) {
            if (*k < *t->k) {
                t->l = splt(t->l).r;
                r = t->updt();
            } else {
                t->r = splt(t->r).l;
                l = t->updt();
            }
        }

        return *this;
    }

    static tr* mrg(tr* l, tr* r) {
        if (!l) return r;
        if (!r) return l;

        if (l->p > r->p) {
            l->r = mrg(l->r, r);
            return l->updt();
        } else {
            r->l = mrg(l, r->l);
            return r->updt();
        }
    }

    static tr* inst(tr* t, tr* n) {
        tr s;

        s.init(n->k).splt(t);

        return mrg(mrg(s.l, n), s.r);
    }

    static tr* rmv(tr* t, K& k, tr** b = NULL) {
        if (k < *t->k) {
            t->l = rmv(t->l, k);
        } else if (k > *t->k) {
            t->r = rmv(t->r, k);
        } else {
            tr* r = mrg(t->l, t->r);

            if (b) *b = t;

            return r;
        }

        return t->updt();
    }

    tr& lth(int n) {
        if (n < cnt(l))
            return l->lth(n);
        else if (n > cnt(l))
            return r->lth(n - cnt(l) - 1);

        return *this;
    }

    static tr* upr(tr* t, K& k) {
        if (!t) return NULL;

        if (k < *t->k) {
            tr* u = upr(t->l, k);
            return u ? u : t;
        } else {
            return upr(t->r, k);
        }
    }

    static tr* lwr(tr* t, K& k) {
        if (!t) return NULL;

        if (k <= *t->k) {
            return lwr(t->l, k);
        } else {
            tr* l = lwr(t->r, k);
            return l ? l : t;
        }
    }

    static int hgt(tr* t, int h = 0) {
        if (!t) return h;

        return 1 + max(hgt(t->l, h), hgt(t->r, h));
    }

    void dmp() {
#ifdef dbg
        k->dmp();

        if (l) pr("(%d", *l->k); else pr("(-");
        if (r) pr(",%d) ", *r->k); else pr(",-) ");
#endif
    }

    static void dmp(tr* t) {
#ifdef dbg
        if (!t) return;

        dmp(t->l);
        dmp(t->r);

        t->dmp();
#endif
    }
};

typedef tr<class dt> td;

td tp[sz];
int tc, nr;

int nrd(td*& t, class dt& d) {
    td* u = td::upr(t, d);

    if (u && d.y < u->k->y)
        return false;

    return true;
}

void rmv(td*& t, class dt& d) {
    class dt k = d;

    for (td *l; l = td::lwr(t, k);) {
        k.x = l->k->x;

        if (l->k->y < d.y)
            t = td::rmv(t, *l->k);
    }
}

int main() {
    clki();

    clk0(0);

    for (scanf("%d", &tc); tc-- > 0;) {
        td *t = NULL;
        int c = 0;

        scanf("%d", &nr);

        for (int i = 0; i < nr; i++) {
            class dt& d = dt[i];

            clk0(2);
            scanf("%d %d", &d.x, &d.y);
            clk1(2);

            if (nrd(t, d)) {
                td* n = &tp[i].init(&d);

                t = td::inst(t, n);

                rmv(t, d);
            }

            c += td::cnt(t);
        }

        printf("%d\n", c);
    }
    clk1(0);

    clkp("total", 0); pr("\n");
    clkp("scanf", 2); pr("\n");

    return 0;
}