#include <bits/stdc++.h>

using namespace std;

#if __cplusplus >= 201103L
    struct pairhash {
        static uint64_t splitmix64(uint64_t x) {
            x += 0x9e3779b97f4a7c15;
            x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
            x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
            return x ^ (x >> 31);
        }

        template<class T, class U>
        size_t operator() (const pair<T,U> &p) const {
            static const uint64_t FIXED_RANDOM = (uint64_t)chrono::steady_clock::now().time_since_epoch().count();
            return splitmix64(p.first + FIXED_RANDOM) ^ splitmix64(p.second+ FIXED_RANDOM);
        }
    };
    struct custom_hash {
        static uint64_t splitmix64(uint64_t x) {
            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 = (uint64_t)chrono::steady_clock::now().time_since_epoch().count();
            return splitmix64(x + FIXED_RANDOM);
        }
    };
    mt19937 rng((uint32_t)chrono::steady_clock::now().time_since_epoch().count());
    inline int randint(int l, int r) {
        return uniform_int_distribution<int>(l,r)(rng);
    }
    inline double randdouble(double l, double r) {
        return uniform_real_distribution<double>(l,r)(rng);
    }
#endif
 
#ifndef ONLINE_JUDGE
#  define LOG(x) (cerr << #x << " = " << (x) << endl)
#else
#  define LOG(x) 0
#endif

#define fastio ios::sync_with_stdio(false); cin.tie(0);
#define ll long long
#define ull unsigned long long
#define ll128 __int128_t
#define PI 3.14159265358979323846
#define abs(a) ((a>0)?a:-(a))
#define pii pair<int,int>
#define pll pair<ll,ll>

const long double pi = acos(-1.0);
const long double eps = (double)1e-2;

int mod = (1<<30);

template<class T>
T qpow(T a, int b) {
    T res = 1;
    while (b) {
        if (b & 1) res *= a;
        a *= a;
        b >>= 1;
    }
    return res;
}
int norm(int x) {
    if (x < 0) {
        x += mod;
    }
    if (x >= mod) {
        x -= mod;
    }
    return x;
}
struct Z {
    int x;
    Z(int x = 0) : x(norm(x)) {}
    Z(ll x) : x(norm((int)(x % mod))) {}
    int val() const {
        return x;
    }
    Z operator-() const {
        return Z(norm(mod - x));
    }
    Z inv() const {
        assert(x != 0);
        return qpow(*this, mod - 2);
    }
    Z &operator*=(const Z &rhs) {
        x = (ll)(x) * rhs.x % mod;
        return *this;
    }
    Z &operator+=(const Z &rhs) {
        x = norm(x + rhs.x);
        return *this;
    }
    Z &operator-=(const Z &rhs) {
        x = norm(x - rhs.x);
        return *this;
    }
    Z &operator/=(const Z &rhs) {
        return *this *= rhs.inv();
    }
    friend Z operator*(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res *= rhs;
        return res;
    }
    friend Z operator+(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res += rhs;
        return res;
    }
    friend Z operator-(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res -= rhs;
        return res;
    }
    friend Z operator/(const Z &lhs, const Z &rhs) {
        Z res = lhs;
        res /= rhs;
        return res;
    }
    friend std::istream &operator>>(std::istream &is, Z &a) {
        ll v;
        is >> v;
        a = Z(v);
        return is;
    }
    friend std::ostream &operator<<(std::ostream &os, const Z &a) {
        return os << a.val();
    }
};

const int maxn = 2e5+5;
const int maxm = 6e5+55;

int n;
struct Node {
    int x, y, idx;
} a[maxn];

struct Edge {
    int to, idx;
};

vector<Edge> adj[maxn<<1];
bool vis[maxn<<1];
vector<pii> ans;
int dep[maxn<<1];

// dfs 返回 >0 代表里面剩了一个边，这个边与 v 直接相连，编号就是返回值
int dfs(int u, int p) {
    dep[u] = dep[p] + 1;
    vis[u] = 1;
    vector<int> vec;
    for (auto [v, idx] : adj[u]) {
        if (v == p) continue;
        if (vis[v] && dep[v] < dep[u]) continue;  // 如果这是一个backward edge
        int r = 1;
        if (!vis[v]) {
            r = dfs(v, u);
            if (r) {
                ans.push_back({r, idx});
            } else {
                vec.push_back(idx);
            }
        } else vec.push_back(idx);
    }
    // vec 里面所有都是与 u 直接相连的
    while (vec.size() >= 2) {
        int i = vec.back(); vec.pop_back();
        int j = vec.back(); vec.pop_back();
        assert(i > 0); assert(j > 0);
        ans.push_back({i,j});
    }
    if (vec.size()) return vec[0];
    return 0;
}

void solve() {
    int N = 0;
    cin >> n; n*=2;
    map<int, int> xs, ys;
    for (int i = 1; i <= n; i++) {
        cin >> a[i].x >> a[i].y;
        if (!xs.count(a[i].x)) xs[a[i].x] = ++N;
        if (!ys.count(a[i].y)) ys[a[i].y] = ++N;
        a[i].idx = i;
        int u = xs[a[i].x], v = ys[a[i].y];
        adj[u].push_back({v, i});
        adj[v].push_back({u, i});
    }

    for (int i = 1; i <= N; i++) {
        if (!vis[i]) dfs(i, 0);
    }

    vector<bool> used(n+5, 0);
    cout << ans.size() << "\n";
    for (auto [u,v] : ans) {
        cout << u << " " << v << "\n";
        used[u] = used[v] = 1;
    }
    vector<int> tmp;
    for (int i = 1; i <= n; i++) {
        if (!used[i]) tmp.push_back(i);
    }
    // LOG(tmp.size());
    for (int i = 0; i < tmp.size(); i+=2) cout << tmp[i] << " " << tmp[i+1] << "\n", assert(tmp[i] > 0), assert(tmp[i+1]>0);

    ans.clear();
    for (int i = 1; i <= N; i++) adj[i].clear();
    fill(vis, vis+N+2, 0);
    fill(dep, dep+N+2, 0);
}

int main() {
    fastio;
    int T; cin >> T;
    while (T--) {
        solve();
    }
}

/*
2
3
-2 0
-1 0
-1 -1
1 1
1 2
2 1
3
-1 0
0 0
1 0
2 0
0 -3
1 -4
*/