You are given an array of integers a_1,a_2,…,a_n. Find the maximum possible value of a_ia_ja_ka_la_t among all five indices (i, j, k, l, t) (i<j<k<l<t).

Input

The input consists of multiple test cases. The first line contains an integer t (1≤ t≤ 2 ⋅ 10^4) — the number of test cases. The description of the test cases follows.

The first line of each test case contains a single integer n (5≤ n≤ 10^5) — the size of the array.

The second line of each test case contains n integers a_1,a_2,…,a_n (-3× 10^3≤ a_i≤ 3× 10^3) — given array.

It's guaranteed that the sum of n over all test cases does not exceed 2⋅ 10^5.

Output

For each test case, print one integer — the answer to the problem.

Example

Input


4
5
-1 -2 -3 -4 -5
6
-1 -2 -3 1 2 -1
6
-1 0 0 0 -1 -1
6
-9 -7 -5 -3 -2 1


Output


-120
12
0
945

Note

In the first test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)⋅ (-2) ⋅ (-3)⋅ (-4)⋅ (-5)=-120.

In the second test case, choosing a_1,a_2,a_3,a_5,a_6 is a best choice: (-1)⋅ (-2) ⋅ (-3)⋅ 2⋅ (-1)=12.

In the third test case, choosing a_1,a_2,a_3,a_4,a_5 is a best choice: (-1)⋅ 0⋅ 0⋅ 0⋅ (-1)=0.

In the fourth test case, choosing a_1,a_2,a_3,a_4,a_6 is a best choice: (-9)⋅ (-7) ⋅ (-5)⋅ (-3)⋅ 1=945.
import java.util.*;
import java.lang.*;
import java.io.*;


public class B

{
    class Pair<S extends Comparable<S>, T extends Comparable<T>> implements Comparable<Pair<S, T>>
    {
        S first;
        T second;

        Pair(S f, T s)
        {
            first = f;
            second = s;
        }

        @Override
        public int compareTo(Pair<S, T> o)
        {
            int t = first.compareTo(o.first);
            if (t == 0) return second.compareTo(o.second);
            return t;
        }

        @Override
        public int hashCode()
        {
            return (31 + first.hashCode()) * 31 + second.hashCode();
        }

        @Override
        public boolean equals(Object o)
        {
            if (!(o instanceof Pair)) return false;
            if (o == this) return true;
            Pair p = (Pair) o;
            return first.equals(p.first) && second.equals(p.second);
        }

        @Override
        public String toString()
        {
            return "Pair{" + first + ", " + second + "}";
        }
    }
    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 nextInt()
        {
            return Integer.parseInt(next());
        }

        long nextLong()
        {
            return Long.parseLong(next());
        }

        double nextDouble()
        {
            return Double.parseDouble(next());
        }

        String nextLine()
        {
            String str = "";
            try
            {
                str = br.readLine();
            }
            catch (IOException e)
            {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static void main (String[] args) throws java.lang.Exception
    {
        try
        {
            System.setIn(new FileInputStream("input.txt"));
            System.setOut(new PrintStream(new FileOutputStream("output.txt")));
        }
        catch (Exception e)
        {
            System.err.println("Error");
        }

        FastReader sc = new FastReader();
        int t = sc.nextInt();
        PrintWriter out = new PrintWriter(System.out);
        while(t-- > 0)
        {
            solve(sc, out);
        }
        out.close();
    }
    static void solve(FastReader sc, PrintWriter out)
    {
        int n = sc.nextInt();
        Long arr[] = new Long[n];
        boolean temp = false;

        for(int i = 0; i < n; i++)
        {
            arr[i] = sc.nextLong();
            if(arr[i] >= 0)
            {
                temp = true;
            }

        }
        long ans=1;
        Arrays.sort(arr);
        if(!temp)
        {
            ans = arr[n - 1] * arr[n - 2] * arr[n - 3] * arr[n - 4] * arr[n - 5];
        }
        else
        {
            Arrays.sort(arr, new Comparator<Long>()
            {
                public int compare(Long a, Long  b)
                {
                    return Long.compare(Math.abs(b),Math.abs(a));

                }
            });
            
            long pos=0,pos1=0,neg1=0,neg=0;
            for(int i = 0; i < 5; i++)
            {
                
                if(arr[i] < 0)
                {
                    neg = arr[i];
                }
                else
                {
                    
                    pos = arr[i];
                }
                ans *= arr[i];
            }
            if(ans < 0)
            {
                boolean temp1=false;
                for(int j = 5; j < n; j++)
                {
                    if(arr[j] < 0)
                    {
                        neg1 = arr[j];
                        break;
                    }
                    
                }
                for(int j = 5; j < n; j++)
                {
                    if(arr[j] >= 0)
                    {
                        temp1=true;
                        pos1 = arr[j];
                        break;
                    }
                    
                }


                if(pos*pos1>neg*neg1){
                    if(neg!=0)
                        ans/=neg;
                    ans*=pos1;
                }
                else if(neg*neg1>pos*pos1){
                    if(pos!=0){
                        ans/=pos;
                        ans*=neg1;
                    }
                    else{
                        ans/=neg;
                        ans*=pos1;
                    }
                    
                }
                else{
                    
                    if(neg1==0){
                        if(temp1){
                            if(neg!=0)
                               ans/=neg;
                            ans*=pos1;
                        }

                    }
                    else{
                        ans/=neg;
                        ans*=pos1;
                    }

                }
            }

        }
        out.println(ans);





    }
}