// Slow solution for problem G
// Author: Grzegorz Gutowski

#include <algorithm>
#include <iostream>
#include <list>
#include <set>
#include <vector>
using namespace std;

const int INF = 2*1000*1000*1000;

struct comp_sec {
    bool operator() (const pair<int, int>& a, const pair<int, int>& b) const {
        return make_pair(a.second, a.first) < make_pair(b.second, b.first);
    }
};

template<typename T>
struct minpos {
    vector<T> v;
    int fni,lni;
    minpos(size_t s, T v) : v(s, v) {
        fni = -1;
        lni = -1;
    }
    void set(size_t t, T u) {
        if (u < INF and (fni == -1 or t < fni))
            fni = t;
        if (u < INF and (lni == -1 or t > lni))
            lni = t;
        v[t] = u;
    }
    size_t min(size_t l, size_t i=1, size_t d=1) {
        size_t p=0;
        if (fni < 0)
            return 0;
        while (fni <= lni and v[fni] == INF)
            fni++;
        while (fni <= lni and v[lni] == INF)
            lni--;
        if (fni>lni) {
            fni = -1;
            lni = -1;
        }
        for (size_t i=fni; i<=lni and i<l; i++)
            if (v[i] < v[p])
                p=i;
        return p;
    }
};

template<typename T>
struct finder {
    vector<T> v;
    vector<pair<T, pair<size_t, T>>> h;
    finder(size_t s) : v(s, 0) {
        size_t p=1;
        while (p<=s)
            p *= 2;
        h.resize(p*2, make_pair((T)0, make_pair((size_t)0,(T)0)));
    }
    void repair(size_t i, T l=1) {
        if (i <= 1)
            return;
        size_t p = i/2;
        h[p].first = h[2*p].first + h[2*p+1].first;
        if (h[2*p].second.second >= h[2*p+1].second.second + h[2*p].first - l)
            h[p].second = h[2*p].second;
        else {
            h[p].second.first = l + h[2*p+1].second.first;
            h[p].second.second = h[2*p+1].second.second + h[2*p].first - l;
        }
        repair(p, 2*l);
    }
    T get(size_t t) {
        return v[t];
    }
    void set(size_t t, T u) {
        v[t] = u;
        h[h.size()/2+t].first = u;
        h[h.size()/2+t].second.first = 0;
        h[h.size()/2+t].second.second = u;
        repair(h.size()/2+t);
    }
    pair<size_t, T> find() {
        return h[1].second;
    }
};


bool solve(const vector<pair<int, int>>& first, int v, vector<pair<int, int>>& S) {
    int N = first.size();
    set<pair<int, int>, comp_sec> inactive(first.begin(), first.end());
    vector<vector<pair<int, int>>> active(N);
    minpos<int> mp(N, INF);
    finder<int> fd(N);
    S.resize(0);
    int nz=0;
    int p = 0;
    for (int i=0; i<N; i++) {
        int f = -1;
        pair<size_t, int> ff = fd.find();
        if (ff.second > v+1)
            return false;
        if (ff.second == v+1)
            f = ff.first;
        else
            f = -1;
        int q = -1;
        if (f >= 0)
            q = mp.min(f+1);
        else
            q = mp.min(N);
        if (q >= 0 and active[q].size() == 0)
            q = -1;
        if (f < 0 and inactive.size() > 0 and (q<0 or comp_sec()(*inactive.begin(), active[q].back())))
            q = -1;
        pair<int, int> r;
        if (q < 0) {
            r = *inactive.begin();
            inactive.erase(inactive.begin());
        } else {
            r = active[q].back();
            active[q].pop_back();
            fd.set(q, fd.get(q)-1);
            if (active[q].size() > 0)
                mp.set(q, active[q].back().second);
            else
                mp.set(q, INF);
        }
        S.push_back(r);
        while (p<N) {
            if (first[p] == r) {
                p++;
                continue;
            }
            if (first[p].first > r.second)
                break;
            inactive.erase(first[p]);
            active[i].push_back(first[p]);
            p++;
        }
        fd.set(i, active[i].size());
        if (active[i].size() > 0) {
            sort(active[i].begin(), active[i].end(), comp_sec());
            reverse(active[i].begin(), active[i].end());
            mp.set(i, active[i].back().second);
        } else
            mp.set(i, INF);
        while (active[nz].size() == 0 and nz<i)
            nz++;
        fd.set(nz, fd.get(nz)+1);
    }
    return true;
}

int solve(vector<pair<int, int>>& I) {
    sort(I.begin(), I.end());
    vector<pair<int, int>> S;
    int l=0;
    int u=I.size();
    while (l<u) {
        int m = (u+l)/2;
        if (solve(I, m, S))
            u = m;
        else
            l = m+1;
    }
    solve(I, u, S);
    swap(I, S);
    return u;
}

void testcase() {
    int N;
    cin >> N;
    vector<pair<int, int>> I(N);
    for (int i=0; i<N; i++)
        cin >> I[i].first >> I[i].second;
    cout << solve(I) << endl;
    for (int i=0; i<N; i++)
        cout << I[i].first << " " << I[i].second << endl;
}

int main() {
    int Z;
    cin >> Z;
    while (Z--)
        testcase();
    return 0;
}