description: You are given a sequence a_1, a_2, ..., a_n consisting of n pairwise distinct positive integers.
  
  Find \left⌊ \frac n 2 \right⌋ different pairs of integers x and y such that: 
  
    * x ≠ y; 
    * x and y appear in a; 
    * x~mod~y doesn't appear in a. 
  
  
  
  Note that some x or y can belong to multiple pairs.
  
  ⌊ x ⌋ denotes the floor function — the largest integer less than or equal to x. x~mod~y denotes the remainder from dividing x by y.
  
  If there are multiple solutions, print any of them. It can be shown that at least one solution always exists.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — the number of testcases.
  
  The first line of each testcase contains a single integer n (2 ≤ n ≤ 2 ⋅ 10^5) — the length of the sequence.
  
  The second line of each testcase contains n integers a_1, a_2, ..., a_n (1 ≤ a_i ≤ 10^6).
  
  All numbers in the sequence are pairwise distinct. The sum of n over all testcases doesn't exceed 2 ⋅ 10^5.
  
  Output
  
  The answer for each testcase should contain \left⌊ \frac n 2 \right⌋ different pairs of integers x and y such that x ≠ y, x and y appear in a and x~mod~y doesn't appear in a. Print the pairs one after another.
  
  You can print the pairs in any order. However, the order of numbers in the pair should be exactly such that the first number is x and the second number is y. All pairs should be pairwise distinct.
  
  If there are multiple solutions, print any of them.
  
  Example
  
  Input
  
  
  4
  2
  1 4
  4
  2 8 3 4
  5
  3 8 5 9 7
  6
  2 7 5 3 4 8
  
  
  Output
  
  
  4 1
  8 2
  8 4
  9 5
  7 5
  8 7
  4 3
  5 2
  
  Note
  
  In the first testcase there are only two pairs: (1, 4) and (4, 1). \left⌊ \frac 2 2 \right⌋=1, so we have to find one pair. 1~mod~4=1, and 1 appears in a, so that pair is invalid. Thus, the only possible answer is a pair (4, 1).
  
  In the second testcase, we chose pairs 8~mod~2=0 and 8~mod~4=0. 0 doesn't appear in a, so that answer is valid. There are multiple possible answers for that testcase.
  
  In the third testcase, the chosen pairs are 9~mod~5=4 and 7~mod~5=2. Neither 4, nor 2, appears in a, so that answer is valid.
solution: # pylint: disable=unused-variable
  # pylint: enable=too-many-lines
  # * Just believe in yourself
   
   
  # $ Author @CAP
  # import numpy
  import os
  import sys
  from io import BytesIO, IOBase
  import math as M
  import itertools as ITR
  from collections import defaultdict as D
  from collections import Counter as C
  from collections import deque as Q
  import threading
  from functools import cmp_to_key, lru_cache, reduce
  from functools import cmp_to_key as CMP
  from bisect import bisect, bisect_left as BL
  from bisect import bisect_right as BR
  import random as R
  import string
  import cmath, time
  from heapq import heapify, heappop as HPOP
  from heapq import heappush as HPUSH
  import heapq as H
   
  enum = enumerate
  start_time = time.time()
   
  # * Variables
   
  MOD = 1_00_00_00_007
  MA = float("inf")
  MI = float("-inf")
   
  # * Graph 8 direction
  d8i = (-1, -1, 0, 1, 1, 1, 0, -1); d8j = (0, 1, 1, 1, 0, -1, -1, -1)
   
  # * Graph 4 direction
  d4i = (-1, 0, 1, 0); d4j=(0, 1, 0, -1)
   
  # * Stack increment
   
   
  def increase_stack():
      sys.setrecursionlimit(2 ** 32 // 2 - 1)
      threading.stack_size(1 << 27)
      # sys.setrecursionlimit(10**6)
      # threading.stack_size(10**8)
      # t = threading.Thread(target=main)
      # t.start()
      # t.join()
   
   
  # * Region Funtions
   
   
  def binary(n):
      return bin(n)[2:]
   
   
  def decimal(s):
      return int(s, 2)
   
   
  def pow2(n):
      p = 0
      while n > 1:
          n //= 2
          p += 1
      return p
   
   
  def maxfactor(n):
      q = []
      for i in range(1, int(n ** 0.5) + 1):
          if n % i == 0:
              q.append(i)
      if q:
          return q[-1]
   
   
  def factors(n):
      q = []
      for i in range(1, int(n ** 0.5) + 1):
          if n % i == 0:
              q.append(i)
              q.append(n // i)
      return list(sorted(list(set(q))))
   
   
  def primeFactors(n):
      l = []
      while n % 2 == 0:
          l.append(2)
          n = n / 2
      for i in range(3, int(M.sqrt(n)) + 1, 2):
          while n % i == 0:
              l.append(i)
              n = n / i
      if n > 2:
          l.append(int(n))
      l.sort()
      return l
   
   
  def isPrime(n):
      if n == 1:
          return False
      else:
          root = int(n ** 0.5)
          root += 1
          for i in range(2, root):
              if n % i == 0:
                  return False
          return True
   
   
  def seive(n):
      a = []
      prime = [True for i in range(n + 1)]
      p = 2
      while p * p <= n:
          if prime[p] == True:
              for i in range(p ** 2, n + 1, p):
                  prime[i] = False
          p = p + 1
      for p in range(2, n + 1):
          if prime[p]:
              a.append(p)
      prime[0] = prime[1] = False
      return a, prime
   
   
  def maxPrimeFactors(n):
      maxPrime = -1
      while n % 2 == 0:
          maxPrime = 2
          n >>= 1
      for i in range(3, int(M.sqrt(n)) + 1, 2):
          while n % i == 0:
              maxPrime = i
              n = n / i
      if n > 2:
          maxPrime = n
      return int(maxPrime)
   
   
  def countchar(s, i):
      c = 0
      ch = s[i]
      for i in range(i, len(s)):
          if s[i] == ch:
              c += 1
          else:
              break
      return c
   
   
  def str_counter(a):
      q = [0] * 26
      for i in range(len(a)):
          q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
      return q
   
   
  def lis(arr):
      n = len(arr)
      lis = [1] * n
      maximum = 0
   
      for i in range(1, n):
          for j in range(0, i):
              if arr[i] > arr[j] and lis[i] < lis[j] + 1:
                  lis[i] = lis[j] + 1
                  maximum = max(maximum, lis[i])
      return maximum
   
   
  def gcd(a, b):
      if b == 0:
          return a
      else:
          return gcd(b, a % b)
   
   
  def agcd(a, *b):
   
      for i in b:
          a = gcd(a, i)
      return a
   
   
  def lcm(a, *b):
      val = a
      gc = a
      for i in b:
          gc = gcd(gc, i)
          val *= i
      return val // gc
   
   
  def ncr(n, r):
      return M.factorial(n) // (M.factorial(n - r) * M.factorial(r))
   
   
  def npr(n, r):
      return M.factorial(n) // M.factorial(n - r)
   
   
  # * Make work easy funtions
   
   
  def IF(c, t, f):
      return t if c else f
   
   
  def YES(c):
      print(IF(c, "YES", "NO"))
   
   
  def Yes(c):
      print(IF(c, "Yes", "No"))
   
   
  def yes(c):
      print(IF(c, "yes", "no"))
   
   
  def JA(a, sep=" "):
      print(sep.join(map(str, a)))
   
   
  def JAA(a, s="\n", t=" "):
      print(s.join(t.join(map(str, b)) for b in a))
   
   
  def PS(a, s=" "):
      print(str(a), end=s)
   
   
  # * Region Taking Input
   
   
  def I():
      return int(inp())
   
   
  def F():
      return float(inp())
   
   
  def LI():
      return list(map(int, inp().split()))
   
   
  def LF():
      return list(map(float, inp().split()))
   
   
  def MATI(n):
      return [LI() for i in range(n)]
   
   
  def MATS(n):
      return [list(inp()) for i in range(n)]
   
   
  def IV():
      return map(int, inp().split())
   
   
  def FV():
      return map(float, inp().split())
   
   
  def LS():
      return list(inp())
   
   
  def S():
      return inp()
   
   
  # * Region Fastio
   
  BUFSIZE = 8192
   
   
  class FastIO(IOBase):
      newlines = 0
   
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
   
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
   
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
   
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
   
   
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
   
   
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  inp = lambda: sys.stdin.readline().rstrip("\r\n")
   
   
  # @==================================== Write The Useful Code Here ============================
   
  # @Make it one if there is some test cases
  TestCases = 1  # @=====================
  # @ =======================================
  
  
  
  
      
  def solve(test_no):
      n=I()
      q=n//2
      arr=LI()
      arr.sort()
      for i in range(q):
          print(arr[i+1],arr[0])
  
  # < This is the Main Function
   
   
  def main():
      flag = 1
      #< Checking we are offline or not
      try:
          sys.stdin = open(
              "C:/Users/raavi.manoj/Documents/coding/python/input.txt",
              "r",
          )
          sys.stdout = open(
              "C:/Users/raavi.manoj/Documents/coding/python/output.txt",
              "w",
          )
      except:
          flag = 0
  
      t = 1
      if TestCases:
          t = I()
      for test in range(1, t + 1):
          solve(test)
   
      if flag:
          print("\nTHIS IS A PYTHON OUTPUT FILE")
          print("Time: %.4f seconds" % (time.time() - start_time))
          localtime = time.asctime(time.localtime(time.time()))
          print(localtime)
          sys.stdout.close()
   
   
  # <  End Region
   
   
  if __name__ == "__main__":
   
      # ? Incresing Stack Limit
      # increase_stack()
   
      #< Calling Main Function
      main()
   
   
   
  
  