#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; }


int N;
vector<Int> A;

vector<pair<Int, Int>> ans;
Int oper(Int a, Int b) {
  assert((a + b) % 2 == 0);
  ans.emplace_back(a, b);
  return (a + b) / 2;
}

bool brute(const vector<Int> &as, vector<pair<Int, Int>> ops) {
  const int asLen = as.size();
  if (asLen == 1) {
    ans.insert(ans.end(), ops.begin(), ops.end());
    return true;
  } else {
    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] = (as[i] + as[j]) / 2;
        bs[j] = bs.back();
        bs.pop_back();
        ops.emplace_back(as[i], as[j]);
        if (brute(bs, ops)) {
          return true;
        }
        ops.pop_back();
      }
    }
    return false;
  }
}

Int solveSame(const vector<Int> &as) {
  vector<Int> bss[2];
  for (const Int a : as) {
    bss[a >> 1 & 1].push_back(a);
  }
  for (; ; ) {
    bool upd = false;
    for (int s = 0; s < 2; ++s) if (bss[s].size() >= 2) {
      const Int b0 = bss[s].back(); bss[s].pop_back();
      const Int b1 = bss[s].back(); bss[s].pop_back();
      const Int b = oper(b0, b1);
      bss[b >> 1 & 1].push_back(b);
      upd = true;
      break;
    }
    if (!upd) break;
  }
  vector<Int> bs;
  for (int s = 0; s < 2; ++s) {
    bs.insert(bs.end(), bss[s].begin(), bss[s].end());
  }
  if (bs.size() == 1) {
    return bs[0];
  } else if (bs.size() == 2) {
    return oper(bs[0], bs[1]);
  } else {
    assert(false);
  }
}

bool solve() {
  ans.clear();
  vector<Int> bss[2];
  for (int i = 0; i < N; ++i) {
    bss[A[i] & 1].push_back(A[i]);
  }
  for (int s = 0; s < 2; ++s) if (bss[s ^ 1].empty()) {
    solveSame(bss[s]);
    return true;
  }
  for (int s = 0; s < 2; ++s) {
    auto &bs = bss[s];
    const int bsLen = bs.size();
    Int mn = -1, mx = 0;
    for (const Int b : bs) {
      mn &= b;
      mx |= b;
    }
    if (mn != mx) {
      const int e = __builtin_ctzll(mn ^ mx);
      if (e < bsLen) {
        for (int i = 1; i < bsLen; ++i) if ((bs[0] ^ bs[i]) >> e & 1) {
          swap(bs[1], bs[i]);
          break;
        }
        Int b = bs[0];
        for (int i = 1; i < e; ++i) {
          b = oper(b, bs[i]);
        }
        vector<Int> cs;
        cs.push_back(b);
        cs.push_back(bs[e]);
        if (e + 1 < bsLen) {
          cs.push_back(solveSame(vector<Int>(bs.begin() + (e + 1), bs.end())));
        }
        cs.push_back(solveSame(bss[s ^ 1]));
        const bool res = brute(cs, {});
        assert(res);
        return true;
      }
    }
  }
  return false;
}

int main() {
  for (int numCases; ~scanf("%d", &numCases); ) { for (int caseId = 1; caseId <= numCases; ++caseId) {
    scanf("%d", &N);
    A.resize(N);
    for (int i = 0; i < N; ++i) {
      scanf("%lld", &A[i]);
    }
#ifdef LOCAL
cerr<<"A = "<<A<<endl;
#endif
    
    const bool res = solve();
    if (res) {
      for (const auto &op : ans) {
        printf("%lld %lld\n", op.first, op.second);
      }
    } else {
      puts("-1");
    }
  }
#ifndef LOCAL
  break;
#endif
  }
  return 0;
}