#include <bits/stdc++.h>
using namespace std;
template<typename T>
int SIZE(T (&t)){
    return t.size();
}

template<typename T, size_t N>
int SIZE(T (&t)[N]){
    return N;
}

string to_string(char t){
    return "'" + string({t}) + "'";
}

string to_string(bool t){
    return t ? "true" : "false";
}

string to_string(const string &t, int x1=0, int x2=1e9){
    string ret = "";
    for(int i = min(x1,SIZE(t)), _i = min(x2,SIZE(t)-1); i <= _i; ++i){
        ret += t[i];
    }
    return '"' + ret + '"';
}

string to_string(const char* t){
    string ret(t);
    return to_string(ret);
}

template<size_t N>
string to_string(const bitset<N> &t, int x1=0, int x2=1e9){
    string ret = "";
    for(int i = min(x1,SIZE(t)); i <= min(x2,SIZE(t)-1); ++i){
        ret += t[i] + '0';
    }
    return to_string(ret);
}

template<typename T, typename... Coords>
string to_string(const T (&t), int x1=0, int x2=1e9, Coords... C);

template<typename T, typename S>
string to_string(const pair<T, S> &t){
    return "(" + to_string(t.first) + ", " + to_string(t.second) + ")";
}

template<typename T, typename... Coords>
string to_string(const T (&t), int x1, int x2, Coords... C){
    string ret = "[";
    x1 = min(x1, SIZE(t));
    auto e = begin(t);
    advance(e,x1);
    for(int i = x1, _i = min(x2,SIZE(t)-1); i <= _i; ++i){
        ret += to_string(*e, C...) + (i != _i ? ", " : "");
        e = next(e);
    }
    return ret + "]";
}

template<int Index, typename... Ts>
struct print_tuple{
    string operator() (const tuple<Ts...>& t) {
        string ret = print_tuple<Index - 1, Ts...>{}(t);
        ret += (Index ? ", " : "");
        return ret + to_string(get<Index>(t));
    }
};

template<typename... Ts>
struct print_tuple<0, Ts...> {
    string operator() (const tuple<Ts...>& t) {
        return to_string(get<0>(t));
    }
};

template<typename... Ts>
string to_string(const tuple<Ts...>& t) {
    const auto Size = tuple_size<tuple<Ts...>>::value;
    return print_tuple<Size - 1, Ts...>{}(t);
}

void dbgr(){;}
template<typename Heads, typename... Tails>
void dbgr(Heads H, Tails... T){
    cout << to_string(H) << " | ";
    dbgr(T...);
}

void dbgs(){;}
template<typename Heads, typename... Tails>
void dbgs(Heads H, Tails... T){
    cout << H << " ";
    dbgs(T...);
}

/*
formatted functions:
*/

/*
consider __VA_ARGS__ as a whole:
dbgv() prints values only
dbg() prints name and values
*/
#define dbgv(...) cout << to_string(__VA_ARGS__) << endl;

#define dbg(...) cout << "[" << #__VA_ARGS__ << "]: "; dbgv(__VA_ARGS__);
//#define dbg(...)

/*
consider __VA_ARGS__ as a sequence of arguments:
dbgr() prints values only
dbgm() prints names and values
*/
#define dbgr(...) dbgr(__VA_ARGS__); cout << endl;

#define dbgm(...) cout << "[" << #__VA_ARGS__ << "]: "; dbgr(__VA_ARGS__);

struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        // http://xorshift.di.unimi.it/splitmix64.c
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }

    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};

typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef pair<int, int> pi;
typedef pair<ll, ll> pll;
// using u128 = __uint128_t;
// using i128 = __int128;
const int mod = 1000000007;
const int N = 400005;
const int LOG = 20;
const int inf = 1e9;
const double eps = 1e-11;
int p[N], dep[N], pedge[N];
pi points[N], xs[N], ys[N], points2[N];
bitset<N> vis, rmv;
vector<pi> adj[N], pairs;
vector<int> notused;
int cnt = 0, cntback = 0;
void dfs(int u) {
    vis[u] = 1;
    int prev = -1, cur = 0;
    vector<int> backedges;
    for (auto [v, idx] : adj[u]) {
        cnt++;
        if (!vis[v]) {
            p[v] = u, pedge[v] = idx, dep[v] = dep[u] + 1;
            dfs(v);
            if (!rmv[v]) {
                if (prev == -1) prev = idx;
                else {
                    pairs.push_back({prev, idx});
                    prev = -1;
                }
            }
        }
        
        else if (idx != pedge[u] && dep[v] < dep[u]) {
            backedges.push_back(idx);
        }
    }
    
    // dbg(backedges);
    int sz = backedges.size();
    if (prev != -1) {
        if (p[u] == -1) {
            notused.push_back(prev);
            return;
        }
        
        if (sz) {
            pairs.push_back({prev, backedges[0]});
            cur++, cntback++;
        }
        
        else {
            pairs.push_back({prev, pedge[u]});
            rmv[u] = 1;
            return;
        }
    }
    
    for (; cur < sz - 1; cur += 2) {
        cntback += 2;
        pairs.push_back({backedges[cur], backedges[cur + 1]});
    }
    
    if (sz - cur == 1) {
        cntback++;
        pairs.push_back({backedges[sz - 1], pedge[u]});
        rmv[u] = 1, cur++;
    }
    
    assert(cur == sz);
}

int n, m, k, qq;
void solve() {
    cin >> n;
    pairs.clear();
    notused.clear();
    for (int i = 0; i < 4 * n; i++) {
        p[i] = -1, vis[i] = 0, rmv[i] = 0, dep[i] = 0;    
        adj[i].clear();
    }
    
    for (int i = 0; i < 2 * n; i++) {
        int x, y;
        cin >> x >> y;
        points[i] = {x, y};
        xs[i] = {x, i}, ys[i] = {y, i};
    }
    
    sort(xs, xs + 2 * n);
    sort(ys, ys + 2 * n);
    int curx = 0, cury = 0;
    for (int i = 0; i < 2 * n; i++) {
        auto [x, idxx] = xs[i];
        auto [y, idxy] = ys[i];
        if (i != 0) {
            auto [xx, temp1] = xs[i - 1];
            auto [yy, temp2] = ys[i - 1];
            if (x != xx) curx++;
            if (y != yy) cury++;
        }
        
        points2[idxx].first = curx;
        points2[idxy].second = cury;
    }
    
    for (int i = 0; i < 2 * n; i++) {
        auto [x, y] = points2[i];
        adj[x].push_back({y + 2 * n, i});
        adj[y + 2 * n].push_back({x, i});
    }
    
    for (int i = 0; i < 2 * n; i++) {
        if (!vis[i]) dfs(i);
        // dbg(cnt);
        // dbg(cnt / 2);
        // dbg(pairs);
        // dbg(notused);
        // dbg(cntback);
        cnt = 0, cntback = 0;
    }
    
    // dbg(pairs);
    cout << pairs.size() << "\n";
    for (auto [p, q] : pairs) {
        cout << p + 1 << " " << q + 1 << "\n";
    }
    
    // dbg(notused);
    // dbg(pairs.size() * 2 + notused.size());
    assert(notused.size() % 2 == 0);
    for (int i = 0; i < notused.size(); i += 2) {
        cout << notused[i] + 1 << " " << notused[i + 1] + 1 << "\n";
    }
}

int32_t main() {
    std::ios::sync_with_stdio(false);
    cin.tie(NULL);
    int tt;
    cin >> tt;
    while (tt--) {
        solve();
    }
}