You are given n integers a_1, a_2, …, a_n and an integer k. Find the maximum value of i ⋅ j - k ⋅ (a_i | a_j) over all pairs (i, j) of integers with 1 ≤ i < j ≤ n. Here, | is the [bitwise OR operator](https://en.wikipedia.org/wiki/Bitwise_operation#OR).

Input

The first line contains a single integer t (1 ≤ t ≤ 10 000) — the number of test cases.

The first line of each test case contains two integers n (2 ≤ n ≤ 10^5) and k (1 ≤ k ≤ min(n, 100)).

The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ n).

It is guaranteed that the sum of n over all test cases doesn't exceed 3 ⋅ 10^5.

Output

For each test case, print a single integer — the maximum possible value of i ⋅ j - k ⋅ (a_i | a_j).

Example

Input


4
3 3
1 1 3
2 2
1 2
4 3
0 1 2 3
6 6
3 2 0 0 5 6


Output


-1
-4
3
12

Note

Let f(i, j) = i ⋅ j - k ⋅ (a_i | a_j).

In the first test case, 

  * f(1, 2) = 1 ⋅ 2 - k ⋅ (a_1 | a_2) = 2 - 3 ⋅ (1 | 1) = -1. 
  * f(1, 3) = 1 ⋅ 3 - k ⋅ (a_1 | a_3) = 3 - 3 ⋅ (1 | 3) = -6. 
  * f(2, 3) = 2 ⋅ 3 - k ⋅ (a_2 | a_3) = 6 - 3 ⋅ (1 | 3) = -3. 



So the maximum is f(1, 2) = -1.

In the fourth test case, the maximum is f(3, 4) = 12.
import java.io.*;
import java.util.*;

public class Codeforces
{
    public static void main(String args[])throws Exception
    {
        BufferedReader bu=new BufferedReader(new InputStreamReader(System.in));
        StringBuilder sb=new StringBuilder();
        int t=Integer.parseInt(bu.readLine());
        while(t-->0)
        {
            String s[]=bu.readLine().split(" ");
            int n=Integer.parseInt(s[0]),k=Integer.parseInt(s[1]);
            int i,a[]=new int[n],c[]=new int[n+1];
            s=bu.readLine().split(" ");
            long ans=Long.MIN_VALUE;
            for(i=0;i<n;i++)
            {
                a[i]=Integer.parseInt(s[i]);
                int cur=i+1;
                if(c[a[i]]!=0) ans=Math.max(ans,1l*cur*c[a[i]]-a[i]*k);    //same number
                c[a[i]]=cur;
            }

            int sz=1,bit=1;
            while(sz<n)
            {
                sz*=2;
                bit++;
            }
            sz=1<<bit;
            int dp[]=new int[sz],M=Integer.MIN_VALUE;
            Arrays.fill(dp,M);
            for(i=1;i<=n;i++)
            if(c[i]!=0)
            {
                dp[i]=c[i];
                if(c[0]!=0) ans=Math.max(ans,1l*dp[i]*c[0]-k*i);   //take cases of 0 with a number
            }

            //for(i=0;i<sz;i++) sb.append(dp[i]+" ");
            //sb.append("\n");
            for(i=1;i<sz;i++)
            {
                int max[]={M,M}, j,l;
                max[0]=dp[i];
                for(j=0;j<bit;j++)
                if(((i>>j)&1)==1)
                {
                    l=i^(1<<j);
                    if(dp[l]==M) continue;
                    if(dp[l]>max[0])
                    {
                        max[1]=max[0]; max[0]=dp[l];
                    }
                    else max[1]=Math.max(max[1],dp[l]);
                }
                if(max[0]!=M && max[1]!=M && max[0]!=max[1]) ans=Math.max(ans,1l*max[0]*max[1]-k*(a[max[0]-1]|a[max[1]-1]));
                dp[i]=max[0];
            }
            sb.append(ans+"\n");
        }
        System.out.print(sb);
    }
}
