#include <bits/stdc++.h>

using namespace std;

#define rep(i, l, r) for (int i = (l); i < (r); ++i)
#define per(i, l, r) for (int i = (r - 1); i >= l; --i)
#define ALL(x) (x).begin(), (x).end()

using i64 = long long;

vector<pair<i64, i64>> main_(vector<i64> A) {
    const int N = (int)A.size();
    array<vector<i64>, 8> B;
    mt19937 mt;
    rep(i, 0, N) {
        B[A[i] % 8].push_back(A[i]);
    }

    auto judge = [&]() {
        auto C = B;
        int sum = C[1].size() + C[3].size() + C[5].size() + C[7].size();

        auto take = [&](int a) {
            for (int i = 1; i <= 7; i += 2) {
                if (a < C[i].size()) {
                    const auto x = C[i].back();
                    C[i].pop_back();
                    return x;
                } else {
                    a -= C[i].size();
                }
            }
            return -1ll;
        };

        vector<pair<i64, i64>> res;

        while (sum >= 2) {
            uniform_int_distribution<int> dist(0, sum - 1);
            i64 a = take(dist(mt));
            --sum;
            dist = uniform_int_distribution<int>(0, sum - 1);
            i64 b = take(dist(mt));
            --sum;
            C[(a + b) / 2 % 8].push_back((a + b) / 2);
            if ((a + b) / 2 % 2 == 1) ++sum;
            res.push_back({a, b});
        }

        bool isOk = false;
        if (sum == 0) isOk = true;
        if (not isOk) {
            rep(a1, 0, 8) rep(b1, 0, 8) {
                if ((a1 + b1) % 2 == 1) continue;
                if (isOk) break;
                if (C[a1].empty()) break;
                i64 x1 = C[a1].back();
                C[a1].pop_back();
                if (C[b1].empty()) {
                    C[a1].push_back(x1);
                    continue;
                }
                i64 y1 = C[b1].back();
                C[b1].pop_back();
                C[(x1 + y1) / 2 % 8].push_back((x1 + y1) / 2);
                res.push_back({x1, y1});
                if (C[1].size() + C[3].size() + C[5].size() + C[7].size() == 0) {
                    isOk = true;
                    break;
                }
                rep(a2, 0, 8) rep(b2, 0, 8) {
                    if ((a2 + b2) % 2 == 1) continue;
                    if (isOk) break;
                    if (C[a2].empty()) break;
                    i64 x2 = C[a2].back();
                    C[a2].pop_back();
                    if (C[b2].empty()) {
                        C[a2].push_back(x2);
                        continue;
                    }
                    i64 y2 = C[b2].back();
                    C[b2].pop_back();
                    C[(x2 + y2) / 2 % 8].push_back((x2 + y2) / 2);
                    res.push_back({x2, y2});
                    if (C[1].size() + C[3].size() + C[5].size() + C[7].size() == 0) {
                        isOk = true;
                        break;
                    }
                    rep(a3, 0, 8) rep(b3, 0, 8) {
                        if ((a3 + b3) % 2 == 1) continue;
                        if (isOk) break;
                        if (C[a3].empty()) break;
                        i64 x3 = C[a3].back();
                        C[a3].pop_back();
                        if (C[b3].empty()) {
                            C[a3].push_back(x3);
                            continue;
                        }
                        i64 y3 = C[b3].back();
                        C[b3].pop_back();
                        C[(x3 + y3) / 2 % 8].push_back((x3 + y3) / 2);
                        res.push_back({x3, y3});
                        if (C[1].size() + C[3].size() + C[5].size() + C[7].size() == 0) {
                            isOk = true;
                            break;
                        }
                        C[(x3 + y3) / 2 % 8].pop_back();
                        C[a3].push_back(x3);
                        C[b3].push_back(y3);
                        res.pop_back();
                    }
                    if (isOk) break;
                    C[(x2 + y2) / 2 % 8].pop_back();
                    C[a2].push_back(x2);
                    C[b2].push_back(y2);
                    res.pop_back();
                }
                if (isOk) break;
                C[(x1 + y1) / 2 % 8].pop_back();
                C[a1].push_back(x1);
                C[b1].push_back(y1);
                res.pop_back();
            }
        }
        if (not isOk) return vector<pair<i64, i64>>();
        vector<i64> x, y;
        copy(ALL(C[0]), back_inserter(x));
        copy(ALL(C[4]), back_inserter(x));
        copy(ALL(C[2]), back_inserter(y));
        copy(ALL(C[6]), back_inserter(y));
        while (x.size() >= 2 or y.size() >= 2) {
            while (x.size() >= 2) {
                i64 a = x[x.size() - 1], b = x[x.size() - 2];
                res.push_back({a, b});
                x.pop_back();
                x.pop_back();
                if ((a + b) / 2 % 4 == 0) x.push_back((a + b) / 2);
                else y.push_back((a + b) / 2);
            }
            while (y.size() >= 2) {
                i64 a = y[y.size() - 1], b = y[y.size() - 2];
                res.push_back({a, b});
                y.pop_back();
                y.pop_back();
                if ((a + b) / 2 % 4 == 0) x.push_back((a + b) / 2);
                else y.push_back((a + b) / 2);
            }
        }
        if (x.empty()) return res;
        if (y.empty()) return res;
        res.push_back({x[0], y[0]});
        return res;
    };

    int tests = 10;
    vector<pair<i64, i64>> ans;
    while (tests--) {
        for (auto &vec : B) {
            shuffle(ALL(vec), mt);
        }
        ans = judge();
        if (not ans.empty()) break;
    }
    return ans;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int T;
    cin >> T;
    while (T--) {
        int N;
        cin >> N;
        vector<i64> A(N);
        for (auto &e : A) cin >> e;
        const auto ans = main_(A);
        if (ans.empty()) cout << -1 << endl;
        else {
            for (const auto &[a, b] : ans) {
                cout << a << ' ' << b << '\n';
            }
            cout << flush;
        }
    }
}