#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }


inline int bsf(Int x) {
  return __builtin_ctzll(x);
}

map<vector<Int>, pair<int, int>> cache;
pair<int, int> brute(const vector<Int> &as) {
  const int asLen = as.size();
  if (asLen <= 1) return make_pair(-2, -2);
  
  auto it = cache.find(as);
  if (it != cache.end()) return it->second;
  pair<int, int> ret(-1, -1);
  
  for (int i = 0; i < asLen; ++i) for (int j = i + 1; j < asLen; ++j) {
    if ((as[i] + as[j]) % 2 == 0) {
      auto bs = as;
      bs[i] = (bs[i] + bs[j]) / 2;
      bs.erase(bs.begin() + j);
      sort(bs.begin(), bs.end());
      const auto res = brute(bs);
      if (~res.first) {
        ret = make_pair(i, j);
        goto foundBrute;
      }
    }
  }
 foundBrute:{}
  
  return cache[as] = ret;
}


Int solveSame(int h, vector<Int> as, vector<pair<Int, Int>> &ops) {
  int n = as.size();
  auto invariant = [&]() -> void {
#ifdef LOCAL
    for (int i = 0; i < n; ++i) {
      assert((as[i] & 1) == h);
    }
#endif
  };
  if (n == 1) {
    return as[0];
  }
  for (; n >= 3; --n) {
    invariant();
    Int &a = as[n - 3], &b = as[n - 2], &c = as[n - 1];
    if (false) {}
    else if ((((b + c) / 2) & 1) == h) { ops.emplace_back(b, c); b = (b + c) / 2; }
    else if ((((a + c) / 2) & 1) == h) { ops.emplace_back(a, c); a = (a + c) / 2; }
    else if ((((a + b) / 2) & 1) == h) { ops.emplace_back(a, b); a = (a + b) / 2; b = c; }
    else {
      assert(false);
    }
  }
  ops.emplace_back(as[0], as[1]);
  return (as[0] + as[1]) / 2;
}

vector<Int> solveParity(int h, vector<Int> as, vector<pair<Int, Int>> &ops) {
  int n = as.size();
  auto invariant = [&]() -> void {
#ifdef LOCAL
    for (int i = 0; i < n; ++i) {
      assert((as[i] & 1) == h);
    }
    Int g = 0;
    for (int i = 1; i < n; ++i) {
      g = __gcd(g, as[i] - as[0]);
    }
    assert(g != 0);
    assert(bsf(g) < n);
#endif
  };
  
  invariant();
  for (; n >= 62; --n) {
    invariant();
    Int &a = as[n - 3], &b = as[n - 2], &c = as[n - 1];
    if (false) {}
    else if ((((b + c) / 2) & 1) == h) { ops.emplace_back(b, c); b = (b + c) / 2; }
    else if ((((a + c) / 2) & 1) == h) { ops.emplace_back(a, c); a = (a + c) / 2; }
    else if ((((a + b) / 2) & 1) == h) { ops.emplace_back(a, b); a = (a + b) / 2; b = c; }
    else {
      assert(false);
    }
  }
  for (; n >= 4; --n) {
    invariant();
    auto yaru = [&](int i, int j) -> void {
      ops.emplace_back(as[i], as[j]);
      as[i] = (as[i] + as[j]) / 2;
      as[j] = as[n - 1];
    };
    // \exists &mask0 ==> \exists &mask1
    for (int i = 0; i < n; ++i) for (int j = i + 1; j < n; ++j) {
      if ((((as[i] + as[j]) / 2) & 1) == h) {
        const Int b = (as[i] + as[j]) / 2;
        Int g = 0;
        for (int k = 0; k < n; ++k) if (i != k && j != k) {
          g = __gcd(g, as[k] - b);
        }
        if (g != 0 && bsf(g) < n - 1) {
          yaru(i, j);
          goto found;
        }
      }
    }
cerr<<"HELP "<<n<<" "<<as<<endl;
    assert(false);
   found:{}
  }
  invariant();
  as.resize(n);
  return as;
}

vector<pair<Int, Int>> solve(const vector<Int> &A) {
  const int N = A.size();
  vector<Int> bss[2];
  for (int i = 0; i < N; ++i) {
    bss[A[i] & 1].push_back(A[i]);
  }
  vector<pair<Int, Int>> ops;
  for (int h = 0; h < 2; ++h) {
    if (bss[h].empty()) {
      solveSame(h ^ 1, bss[h ^ 1], ops);
      return ops;
    }
  }
  for (int h = 0; h < 2; ++h) {
    Int g = 0;
    for (const Int b : bss[h]) {
      g = __gcd(g, b - bss[h][0]);
    }
    if (g != 0 && bsf(g) < (int)bss[h].size()) {
      const Int c1 = solveSame(h ^ 1, bss[h ^ 1], ops);
      auto cs = solveParity(h, bss[h], ops);
      cs.push_back(c1);
// cerr<<A<<" -> "<<cs<<endl;
      sort(cs.begin(), cs.end());
      for (; cs.size() > 1; ) {
        const auto res = brute(cs);
        assert(~res.first);
        const int i = res.first, j = res.second;
        ops.emplace_back(cs[i], cs[j]);
        cs[i] = (cs[i] + cs[j]) / 2;
        cs.erase(cs.begin() + j);
        sort(cs.begin(), cs.end());
      }
      return ops;
    }
  }
  return ops;
}


void judge(const vector<Int> &A, const vector<pair<Int, Int>> &ops) {
  multiset<Int> as(A.begin(), A.end());
  for (const auto &op : ops) {
    for (const Int x : {op.first, op.second}) {
      auto it = as.find(x);
      assert(it != as.end());
      as.erase(it);
    }
    assert((op.first + op.second) % 2 == 0);
    as.insert((op.first + op.second) / 2);
  }
  assert(as.size() == 1);
}

void test(const vector<Int> &as) {
  const int n = as.size();
  const auto res = brute(as);
  set<Int> ss[2];
  for (int i = 0; i < n; ++i) {
    ss[as[i] & 1].insert(as[i]);
  }
  Int gs[2] = {};
  for (int h = 0; h < 2; ++h) {
    for (const Int a : ss[h]) {
      gs[h] = __gcd(gs[h], a - *ss[h].begin());
    }
  }
  
  if (!~res.first) {
    // cout << as << ": " << res << " " << gs[0] << " " << gs[1] << endl;
  }
  bool good = false;
  for (int h = 0; h < 2; ++h) {
    const int sz = ss[h].size();
    good = good || (gs[h] != 0 && bsf(gs[h]) < sz);
  }
  if (good) {
    if (!~res.first) {
      cerr << as << ": " << res << " " << gs[0] << " " << gs[1] << endl;
    }
    assert(~res.first);
  }
  
  /*
  if (ss[0].empty() || ss[1].empty()) {
    const auto slv = solve(as);
    assert(!as.empty());
    judge(as, slv);
  }
  */
  const auto slv = solve(as);
  if (~res.first) {
    judge(as, slv);
  } else {
    assert(slv.empty());
  }
}
void dfs(int n, int limA, int i, vector<Int> &as) {
  if (i == n) {
    test(as);
  } else {
    for (as[i] = i ? as[i - 1] : 0; as[i] < limA; ++as[i]) {
      dfs(n, limA, i + 1, as);
    }
  }
}
void stress() {
  for (int n = 2; n <= 11; ++n) {
    vector<Int> as(n);
    dfs(n, 17, 0, as);
    cerr << "DONE n = " << n << endl;
  }
}

int main() {
  // stress(); return 0;
  
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    int N;
    scanf("%d", &N);
    vector<Int> A(N);
    for (int i = 0; i < N; ++i) {
      scanf("%lld", &A[i]);
    }
    sort(A.begin(), A.end());
    
    const auto ans = solve(A);
    if (!ans.empty()) {
      for (const auto &op : ans) {
        printf("%lld %lld\n", op.first, op.second);
      }
    } else {
      puts("-1");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}