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: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.util.ArrayList;
  import java.util.Collections;
  import java.util.StringTokenizer;
  
  public class Solve {
  
  	static long MOD = 998244353L;
  	static long INF = 1000_000_000_000_000L + 100;
  	static boolean isPrime[];
  
  	public static void main(String[] args) throws Exception {
  		Scanner sc = new Scanner();
  		PrintWriter pw = new PrintWriter(System.out);
  
  		int t = sc.nextInt();
  		while (t-- > 0) {
  			int n = sc.nextInt();
  			int a[] = sc.nextIntArray(n);
  			sort(a);
  			int min = a[0];
  			int sz = n / 2;
  
  			StringBuilder sb = new StringBuilder();
  			int idx = 1;
  			for (int i = 1; i <= sz; i++) {
  				sb.append(a[idx] + " " + min);
  				sb.append("\n");
  				idx++;
  
  			}
  			pw.print(sb);
  
  		}
  		pw.flush();
  
  	}
  
  	static int LowerBound(int a[], int x, int start) { // x is the target value or key
  		int ans = -1;
  
  		int l = start, r = a.length;
  		while (l + 1 < r) {
  			System.out.println("lolk");
  
  			int m = (l + r) >>> 1;
  			if (a[m] >= x) {
  				ans = m;
  				r = m;
  			} else
  				l = m;
  		}
  		return ans;
  	}
  
  	static int UpperBound(int a[], int x, int start) {// x is the key or target value
  		int ans = -1;
  
  		int l = start, r = a.length;
  		while (l + 1 < r) {
  			int m = (l + r) >>> 1;
  			if (a[m] <= x) {
  				ans = m;
  				l = m;
  			} else
  				r = m;
  		}
  		return ans;
  	}
  
  	static public boolean[] sieve(int n) {
  		boolean prime[] = new boolean[n + 1];
  		for (int i = 0; i <= n; i++)
  			prime[i] = true;
  
  		for (int p = 2; p * p <= n; p++) {
  			// If prime[p] is not changed, then it is a
  			// prime
  			if (prime[p] == true) {
  				// Update all multiples of p
  				for (int i = p * p; i <= n; i += p)
  					prime[i] = false;
  			}
  		}
  		return prime;
  
  	}
  
  	public static ArrayList<Integer> primeFactors(int n) {
  		ArrayList<Integer> set = new ArrayList<Integer>();
  
  		// Print the number of 2s that divide n
  		while (n % 2 == 0) {
  			n /= 2;
  			set.add(2);
  		}
  
  		// n must be odd at this point. So we can
  		// skip one element (Note i = i +2)
  		for (int i = 3; i * i <= n; i += 2) {
  			// While i divides n, print i and divide n
  			while (n % i == 0) {
  				n /= i;
  				set.add(i);
  			}
  		}
  
  		if (n > 1)
  			set.add(n);
  
  		return set;
  
  	}
  
  	static long gcd(long a, long b) {
  		if (a == 0)
  			return b;
  		if (b == 0)
  			return a;
  
  		return gcd(b, a % b);
  
  	}
  
  	public static int[] swap(int data[], int left, int right) {
  
  		// Swap the data
  		int temp = data[left];
  		data[left] = data[right];
  		data[right] = temp;
  
  		// Return the updated array
  		return data;
  	}
  
  	public static long[] euclidExtended(long a, long b) {
  		if (b == 0) {
  			long ar[] = new long[] { 1, 0 };
  			return ar;
  		}
  		long ar[] = euclidExtended(b, a % b);
  		long temp = ar[0];
  		ar[0] = ar[1];
  		ar[1] = temp - (a / b) * ar[1];
  		return ar;
  	}
  
  	public static long modInverse(long a, long m) {
  		long ar[] = euclidExtended(a, m);
  		return ((ar[0] % m) + m) % m;
  	}
  
  	// Fermat Theorem
  	public static long ncr(int n, int r, long[] fact) {
  		if (n == r)
  			return 1;
  		if (r == 1)
  			return n;
  		if (n == 0 || r == 0)
  			return 1;
  		return (fact[n] * modInverse(((long) fact[n - r]) * fact[r], MOD)) % MOD;
  	}
  
  	static void sort(int[] a) {
  		ArrayList<Integer> l = new ArrayList<>();
  		for (int i : a)
  			l.add(i);
  		Collections.sort(l);
  		for (int i = 0; i < a.length; i++)
  			a[i] = l.get(i);
  	}
  
  }
  
  class Pair {
  	int x, y;
  
  	Pair(int x, int y) {
  		this.x = x;
  		this.y = y;
  	}
  
  }
  
  class SegTree {
  	int leftmost, rightmost, sum;
  	SegTree lChild, rChild;
  
  	public SegTree(int leftmost, int rightmost) {
  		this.leftmost = leftmost;
  		this.rightmost = rightmost;
  	}
  
  	public void update(int index, int val) {
  		sum++;
  		if (leftmost == rightmost) {
  			return;
  		}
  		if (lChild == null)
  			makeKids();
  		if (index <= lChild.rightmost)
  			lChild.update(index, val);
  		else
  			rChild.update(index, val);
  	}
  
  	public void makeKids() {
  		int mid = (leftmost + rightmost) / 2;
  		lChild = new SegTree(leftmost, mid);
  		rChild = new SegTree(mid + 1, rightmost);
  	}
  
  	public int query(int l, int r) {
  		if (l <= leftmost && r >= rightmost)
  			return sum;
  		if (l > rightmost || r < leftmost)
  			return 0;
  		if (lChild == null)
  			return 0;
  		return lChild.query(l, r) + rChild.query(l, r);
  	}
  }
  
  class UnionFind {
  	int[] p, rank, setSize;
  	int numSets;
  
  	public UnionFind(int N) {
  		p = new int[numSets = N];
  		rank = new int[N];
  		setSize = new int[N];
  		for (int i = 0; i < N; i++) {
  			p[i] = i;
  			setSize[i] = 1;
  		}
  	}
  
  	public int findSet(int i) {
  		return p[i] == i ? i : (p[i] = findSet(p[i]));
  	}
  
  	public boolean isSameSet(int i, int j) {
  		return findSet(i) == findSet(j);
  	}
  
  	public void unionSet(int i, int j) {
  		if (isSameSet(i, j))
  			return;
  		numSets--;
  		int x = findSet(i), y = findSet(j);
  		if (rank[x] > rank[y]) {
  			p[y] = x;
  			setSize[x] += setSize[y];
  		} else {
  			p[x] = y;
  			setSize[y] += setSize[x];
  			if (rank[x] == rank[y])
  				rank[y]++;
  		}
  	}
  
  	public int numDisjointSets() {
  		return numSets;
  	}
  
  	public int sizeOfSet(int i) {
  		return setSize[findSet(i)];
  	}
  }
  
  class Scanner {
  	BufferedReader br;
  	StringTokenizer st;
  
  	Scanner() {
  		br = new BufferedReader(new InputStreamReader(System.in));
  	}
  
  	String next() throws IOException {
  		while (st == null || !st.hasMoreElements())
  			st = new StringTokenizer(br.readLine());
  		return st.nextToken();
  	}
  
  	int nextInt() throws NumberFormatException, IOException {
  		return Integer.parseInt(next());
  	}
  
  	int[] nextIntArray(int n) throws NumberFormatException, IOException {
  		int a[] = new int[n];
  		for (int i = 0; i < n; i++)
  			a[i] = Integer.parseInt(next());
  		return a;
  	}
  
  	long nextLong() throws NumberFormatException, IOException {
  		return Long.parseLong(next());
  	}
  
  	long[] nextLongArray(int n) throws NumberFormatException, IOException {
  		long a[] = new long[n];
  		for (int i = 0; i < n; i++)
  			a[i] = Long.parseLong(next());
  		return a;
  	}
  
  	double nextDouble() throws NumberFormatException, IOException {
  		return Double.parseDouble(next());
  	}
  }