Problem: You are given an array a of 2n distinct integers. You want to arrange the elements of the array in a circle such that no element is equal to the the arithmetic mean of its 2 neighbours.

More formally, find an array b, such that: 

  * b is a permutation of a.

  * For every i from 1 to 2n, b_i ≠ \frac{b_{i-1}+b_{i+1}}{2}, where b_0 = b_{2n} and b_{2n+1} = b_1.




It can be proved that under the constraints of this problem, such array b always exists.

Input

The first line of input contains a single integer t (1 ≤ t ≤ 1000) — the number of testcases. The description of testcases follows.

The first line of each testcase contains a single integer n (1 ≤ n ≤ 25).

The second line of each testcase contains 2n integers a_1, a_2, …, a_{2n} (1 ≤ a_i ≤ 10^9) — elements of the array.

Note that there is no limit to the sum of n over all testcases.

Output

For each testcase, you should output 2n integers, b_1, b_2, … b_{2n}, for which the conditions from the statement are satisfied.

Example

Input


3
3
1 2 3 4 5 6
2
123 456 789 10
1
6 9


Output


3 1 4 2 5 6
123 10 456 789
9 6

Note

In the first testcase, array [3, 1, 4, 2, 5, 6] works, as it's a permutation of [1, 2, 3, 4, 5, 6], and (3+4)/(2)≠ 1, (1+2)/(2)≠ 4, (4+5)/(2)≠ 2, (2+6)/(2)≠ 5, (5+3)/(2)≠ 6, (6+1)/(2)≠ 3.

Solution (in JAVA):

Solution:
/*
 
    /$$$$$  /$$$$$$  /$$    /$$  /$$$$$$                                                                  
   |__  $$ /$$__  $$ |$$    |$$ /$$__  $$                                                                 
          | $$| $$  \ $$|    $$|$$| $$  \ $$                                                                 
          | $$| $$$$$$$$|  $$ / $$/| $$$$$$$$                                                                 
/ $$  | $$| $$__  $$ \  $$ $$/ | $$__  $$                                                                 
| $$  | $$| $$  | $$  \  $$$/  | $$  | $$                                                                 
|  $$$$$$/| $$  | $$   \  $/   | $$  | $$                                                                 
 \______/ |__/  |__/    \_/    |__/  |__/    
 
/$$$$$$$  /$$$$$$$   /$$$$$$   /$$$$$$  /$$$$$$$   /$$$$$$  /$$      /$$ /$$      /$$ /$$$$$$$$ /$$$$$$$ 
| $$__  $$| $$__  $$ /$$__  $$ /$$__  $$| $$__  $$ /$$__  $$| $$$    /$$$| $$$    /$$$| $$_____/| $$__  $$
| $$  \ $$| $$  \ $$| $$  \ $$| $$  \__/| $$  \ $$| $$  \ $$| $$$$  /$$$$| $$$$  /$$$$| $$      | $$  \ $$
| $$$$$$$/| $$$$$$$/| $$  | $$| $$ /$$$$| $$$$$$$/| $$$$$$$$| $$ $$/$$ $$| $$ $$/$$ $$| $$$$$   | $$$$$$$/
| $$____/ | $$__  $$| $$  | $$| $$|_  $$| $$__  $$| $$__  $$| $$  $$$| $$| $$  $$$| $$| $$__/   | $$__  $$
| $$      | $$  \ $$| $$  | $$| $$  \ $$| $$  \ $$| $$  | $$| $$\  $ | $$| $$\  $ | $$| $$      | $$  \ $$
| $$      | $$  | $$|  $$$$$$/|  $$$$$$/| $$  | $$| $$  | $$| $$ \/  | $$| $$ \/  | $$| $$$$$$$$| $$  | $$
|__/      |__/  |__/ \______/  \______/ |__/  |__/|__/  |__/|__/     |__/|__/     |__/|________/|__/  |__/
                                                                                                           
                                                                                                                                                                                                                 
                                                                                                                                                                                                                
 
*/
////solution at bottom 
import java.util.*;
import java.lang.*;
import java.io.*;
 
/* Name of the class has to be "Main" only if the class is public. */
    public class test
{
    static void shuffle( int arr[])
    {
        int n = arr.length;
        Random r = new Random();
         
       for (int i = n-1; i > 0; i--) {
           int j = r.nextInt(i+1);
             
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    static void shuffle( int arr[][])
    {
        int n = arr.length;
        Random r = new Random();
         
       for (int i = n-1; i > 0; i--) {
           int j = r.nextInt(i+1);
             
            int[] temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
        }
    }
    
    static class FastReader 
    { 
        BufferedReader br; 
        StringTokenizer st; 
  
        public FastReader() 
        { 
            br = new BufferedReader(new
                     InputStreamReader(System.in)); 
        } 
  
        String next() 
        { 
            while (st == null || !st.hasMoreElements()) 
            { 
                try
                { 
                    st = new StringTokenizer(br.readLine()); 
                } 
                catch (IOException  e) 
                { 
                    e.printStackTrace(); 
                } 
            } 
            return st.nextToken(); 
        }
         
        int[][] tdiarr(int m , int n){
            int[][] a = new int[m][n];
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    a[i][j]=Integer.parseInt(next());
                }
            }
            return a;
        }
        long[][] tdlarr(int m , int n){
            long[][] a = new long[m][n];
            for(int i=0;i<m;i++){
                for(int j=0;j<n;j++){
                    a[i][j]=Long.parseLong(next());
                }
            }
            return a;
        }

        int[] niarr(int n)
        {
            int[] a = new int[n];
            for(int i=0;i<n;i++)a[i]=Integer.parseInt(next());
            return a;
        }
        long[] nlarr(int n)
        {
            long[] a = new long[n];
            for(int i=0;i<n;i++)a[i]=Long.parseLong(next());
            return a;
        }
        char[] ncarr(){
            return next().trim().toCharArray();
            
            
        }
        
  
        int ni() 
        { 
            return Integer.parseInt(next()); 
        } 
  
        long nl() 
        { 
            return Long.parseLong(next()); 
        } 
  
        double nd() 
        { 
            return Double.parseDouble(next()); 
        } 
  
        String nstr() 
        { 
            String str = ""; 
            try
            { 
                str = br.readLine(); 
            } 
            catch (IOException e) 
            { 
                e.printStackTrace(); 
            } 
            return str; 
        } 
    }
    
    static void SegmentTree(int arr[], int n)
    {
        // Allocate memory for segment tree
        //Height of segment tree
        int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
 
        //Maximum size of segment tree
        int max_size = 2 * (int) Math.pow(2, x) - 1;
 
         int[] st = new int[max_size]; // Memory allocation
 
        constructSTUtil(arr, 0, n - 1, 0);
    }
    static int constructSTUtil(int arr[], int ss, int se, int si)
    {
        // If there is one element in array, store it in current node of
        // segment tree and return
        if (ss == se) {
            st[si] = arr[ss];
            return arr[ss];
        }
 
        // If there are more than one elements, then recur for left and
        // right subtrees and store the sum of values in this node
        int mid = getMid(ss, se);
        st[si] = Math.min(constructSTUtil(arr, ss, mid, si * 2 + 1) ,
                 constructSTUtil(arr, mid + 1, se, si * 2 + 2));
        return st[si];
    }
    static int getMid(int s, int e) {
        return s + (e - s) / 2;
    }
    static int getSum(int n, int qs, int qe)
    {
        // Check for erroneous input values
        if (qs < 0 || qe > n - 1 || qs > qe) {
           // System.out.println("Invalid Input");
            return -1;
        }
        return getSumUtil(0, n - 1, qs, qe, 0);
    }
    static int getSumUtil(int ss, int se, int qs, int qe, int si)
    {
        // If segment of this node is a part of given range, then return
        // the sum of the segment
        if (qs <= ss && qe >= se)
            return st[si];
 
        // If segment of this node is outside the given range
        if (se < qs || ss > qe)
            return Integer.MAX_VALUE;
 
        // If a part of this segment overlaps with the given range
        int mid = getMid(ss, se);
        return Math.min(getSumUtil(ss, mid, qs, qe, 2 * si + 1) ,
                getSumUtil(mid + 1, se, qs, qe, 2 * si + 2));
    }
    static void updateValue(int arr[], int n, int i, int new_val)
    {
        // Check for erroneous input index
        if (i < 0 || i > n - 1) {
//            System.out.println("Invalid Input");
            return;
        }
 
        // Get the difference between new value and old value
        int diff = new_val - arr[i];
 
        // Update the value in array
        arr[i] = new_val;
 
        // Update the values of nodes in segment tree
        updateValueUtil(0, n - 1, i, diff, 0);
    }
    static void updateValueUtil(int ss, int se, int i, int diff, int si)
    {
        // Base Case: If the input index lies outside the range of
        // this segment
        if (i < ss || i > se)
            return;
 
        // If the input index is in range of this node, then update the
        // value of the node and its children
        st[si] = st[si] + diff;
        if (se != ss) {
            int mid = getMid(ss, se);
            updateValueUtil(ss, mid, i, diff, 2 * si + 1);
            updateValueUtil(mid + 1, se, i, diff, 2 * si + 2);
        }
    }
    static boolean checkbound(int x , int y , int m , int n){
        if(x<0 || x>=m || y<0 || y>=n)return false;
        return true;
    }
    static void printarr(int[][] a){
        int m = a.length , n = a[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
    static void printarr(char[][] a){
        int m = a.length , n = a[0].length;
        for(int i=0;i<m;i++){
            for(int j=0;j<n;j++){
                System.out.print(a[i][j]+" ");
            }
            System.out.println();
        }
    }
    static void printarr(int[] a){
        int n = a.length;
        StringBuilder sb = new StringBuilder();
            for(int j=0;j<n;j++){
                sb.append(a[j]+" ");//System.out.print(a[j]+" ");
            }
            System.out.println(sb);
 
        
    }
 
    static void revarr(int[] a ){
        int i=0,j=a.length-1;
        while(i<j){
            int tem = a[i];
            a[i]=a[j];
            a[j]=tem;
            i++;j--;
        }
        //return a;
    }
   
    
 
     static boolean[] sieveOfEratosthenes(int n)
    {
        // Create a boolean array
        // "prime[0..n]" and
        // initialize all entries
        // it as true. A value in
        // prime[i] will finally be
        // false if i is Not a
        // prime, else true.
        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;
            }
        }
        prime[1]=false;
 
        return prime;
    }
    static int gcd(int a, int b)
    {
        if (a == 0)
            return b;
         
        return gcd(b%a, a);
    }
    static int lcm(int a, int b)
    {
        return (a / gcd(a, b)) * b;
    }
    static long gcd(long a, long b)
    {
        if (a == 0L)
            return b;
         
        return gcd(b%a, a);
    }
    static long lcm(long a, long b)
    {
        return (a / gcd(a, b)) * b;
    }
    public static class Pair{
        int x;
        int y;
 
        public Pair(int x, int y){
            this.x = x;
            this.y = y;
        }
 
         
    }
    
    static int[] st;
    static FastReader br=new FastReader();//(new InputStreamReader(System.in));
/*
 
*/
///////////////////////////////////////////////////////////
 
 
 
 
 
    public static void main (String[] args) throws java.lang.Exception
    {
        // your code goes here
        int t=1;
        br=new FastReader();
                                  t=br.ni();//Integer.parseInt(br.readLine().trim());
        StringBuilder sb=new StringBuilder();
        
    in1 :   for(int TC = 1; TC <= t ; TC++)
        {
               //  sb.append(solve()+"\n");
         //   System.out.print("Case "+TC+": ");
           
                      solve();
                      
           
 
        }
          
            //          System.out.println("OUTPUT:::");
    
        System.out.println(sb);
    }
    ///end main
    
    static void solve() throws Exception{
             int n = br.ni();
             int[] a = br.niarr(2 * n);
             shuffle(a);
             Arrays.sort(a);
             int[] b = new int[n*2];
             int i = 0 , j=0;
             n*=2;
             while( i < n && j < n){
                b[j] = a[i];
                j+=2;
                i++;
             }
             j=n-1;
             while(i<n && j>=0){
                b[j]=a[i];
                j-=2;
                i++;
             }
             printarr(b);

            }
    //end solve
            

    }
    //end class    
    /* stuff you should look for
    * int overflow, array bounds
    * special cases (n=1?)
    * do smth instead of nothing and stay organized
    * WRITE STUFF DOWN
    * DON'T GET STUCK ON ONE APPROACH
             }
             }
             }
*/
 
    /*
     
 TC:
4, 6, 4, 5, 6, 2]
1  2  1  2  3   1
1   2   1   1    2   1
1   2   1   1   2   1

 
 
 
      */