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.
// Motto:-Fail early,Fail Often,Fail Forward.
//  while(true)
// {
//     if(AC)
//     {
//         break;
//     }
//     else if(Contest Over)
//     {
//         Try.
//         Check out Editorial.
//         Understand.
//         Find out your Mistake.
//         Learn the topic (if new).
//         Solve Problems on that topic (if new).
//         Upsolve that problem.
//         break;
//     }
//     else
//     {
//         Try.
//         Use Pen-Paper.
//         Find errors, edge cases, etc.
//         continue;
//     }
// }
// Getting TLE ? Do check for long long int optimisation.
// If A^x , if x is very large , you can do x%=(MOD-1)
    #include<bits/stdc++.h>
    using namespace std;
    #include <ext/pb_ds/assoc_container.hpp>
    #include <ext/pb_ds/tree_policy.hpp>
    using namespace __gnu_pbds;
  
    #define ordered_set tree<int, null_type,less<int>, rb_tree_tag,tree_order_statistics_node_update>
     #define ordered_set_pair tree<pair<int,int>, null_type,less<pair<int,int> >, rb_tree_tag,tree_order_statistics_node_update>
    //=============================LOL======================
    #define int         long long
    #define double      long double
    #define pb          push_back
    #define pf          push_front
    #define pii         pair<int,int>
    #define vi          vector<int>
    #define vnn         vector<vector<int>>
    #define vii         vector<pii>
    #define vs          vector<string>
    #define all(a)      (a).begin(),(a).end()
    #define rall(a)     (a).rbegin(),(a).rend()
    #define x           first
    #define y           second
    #define endl        '\n'
    #define sz(x)       (int)(x).size()
    #define thunder     ios_base::sync_with_stdio(false);cin.tie(0);cout.tie(0)
    #ifndef ONLINE_JUDGE
       #define debug(x)    cerr<<#x<<" "<<x<<endl;
    #else 
       #define debug(x)
    #endif  
    //=============================LOL========================
    //++++++++++++++++++++++++Optimisations+++++++++++++++
    //#pragma GCC optimize("O1") 
    //#pragma GCC optimize("O2")
    //#pragma GCC optimize("O3") 
    //#pragma GCC optimize("Os") 
    //#pragma GCC optimize("Ofast") 
    //#pragma GCC optimize("Ofast")  
    //#pragma GCC target("avx,avx2,fma")
    //++++++++++++++++++++++++++++++++++++++++++++++++++++++ 
    //=========================Chal,Nikal.ab==========================
    #define fo(i,l,u)   for(i=l;i<u;i++)
    #define rfo(i,l,u)  for(i=l;i>=u;i--)
    #define allfo(s)    for(auto it=(s).begin();it!=(s).end();it++)
    #define _init(b)     memset(b,-1,sizeof(b))
    #define _init0(b)     memset(b,0,sizeof(b))
    #define MOD         1000000007
    #define hell        998244353
    #define output(x) cout << (x ? "YES" : "NO")<<endl;
    #define Output(x) cout << (x ? "Yes" : "No")<<endl;
    //=========================Chal,Nikal.ab=============================
    //---------------------------Hushiyari mat dikha---------------------------------
    #define MOD2 (998244353)
    #define MOD3 (1000000009)
    #define PI acos(-1)
    #define eps (1e-8)
    #define INF (1e18) 
    template<class A,class B>ostream&operator<<(ostream&out,const pair<A,B>&a){return out<<"("<<a.first<<","<<a.second<<")";}
    template<class A>ostream&operator<<(ostream&out,const vector<A>&a){for(const A &it:a)out<<it<<" ";return out;}
    template<class A,class B>istream&operator>>(istream&in,pair<A,B>&a){return in>>a.first>>a.second;}
    template<class A>istream&operator>>(istream&in,vector<A>&a){for(A &i:a)in>>i;return in;}
    ifstream cinn("in.txt");ofstream coutt("out.txt");
    int poww(const int &a,int b,const int &m=MOD){if(b==0)return 1;int x=poww(a,b/2,m);x=x*x%m;if(b&1)x=x*a%m;return x;} 
    //---------------------------Hushiyari mat dikha--------------------------------------
    int gcd(int a, int b) 
    { 
    if (b == 0) 
        return a; 
    return gcd(b, a % b);    
    }
    int _sum(int n)
    {
        return (n*(n+1))/2;
    }
    int distSq(pii p, pii q) 
    { 
    return (p.x - q.x) * (p.x - q.x) + (p.y - q.y) * (p.y - q.y);  
    }
    // vi fact(101);/
    // int nCr(int n, int r)
    // {
    //    if(!r) return 1;
    //    return (n*nCr(n-1,r-1))/r;
    // }
    const int N = 2e6 + 5;
    // int k,mx=-1,spe;
    // vi adj[N];int vis[N];
    // int dis[N];
    // map<int,int> mm;
    int isPalindrome(string str)
    {
    int low = 0;
    int high = str.length() - 1;
 
    while (low < high)
    {
        // if a mismatch happens
        if (str[low] != str[high]) {
            return -1;
        }
 
        low++;
        high--;
    }
    return str.length();
    }
    
    // bool comp (string a,string b)
    // {
    //     if(a.length()==b.length())
    //     {
    //         return a<b;
    //     }
    //     return a.length()<b.length();
    // }
    // void build_tree(int l,int r,vi &v,vi &d,int curd)
    // {
    //     if(l>r) return;
    //     if(l==r)
    //     {
    //         d[l]=curd;
    //     }
    //     int mx=l,i;
    //     fo(i,l+1,r+1)
    //     {
    //         if(v[mx]<v[i])
    //         {
    //             mx=i;
    //         }
    //     }
    //     d[mx]=curd;
    //     build_tree(l,mx-1,v,d,curd+1);
    //     build_tree(mx+1,r,v,d,curd+1);

    // }
    // int ok=1;
    // vii p;
    // int mn=1e18;
    // int dis=1e18,fi=0;
    // void dfs(int node,int tar,int c=0)
    // {
    //     vis[node]=1;
    //     if(node==tar)
    //     {
    //         fi=1;
    //         dis=min(dis,c);
    //         return;
    //     }
    //     for(int n : adj[node])
    //     {
    //         if(!vis[n])
    //         {
    //             dfs(n,tar,c+1);
    //         }
    //     }
    // }
    // int th=-1;
    // void dfs1(int node,int c,int spe)
    // {
    //     vis[node]=1;
    //     if(node==spe) 
    //     {
    //         th=c;
    //         return;
    //     }
    //     // if(sz(adj[node])!=2) ok=0;
    //     for(int n : adj[node])
    //     {
    //         if(!vis[n])
    //         {
    //             dfs1(n,c+1,spe);
    //         }
    //     }
    // }
    // bool cycleBfs(int node)
    // {
    //     queue<pii> q;
    //     q.push({node,-1});
    //     vis[node]=1;
    //     while(!q.empty())
    //     {
    //         int node =q.front().x;
    //         int prev = q.front().y;
    //         q.pop();
    //         for(int n : adj[node])
    //         {
    //             if(vis[n] && prev!=n) return true;
    //             if(!vis[n])
    //             {
    //                 vis[n]=1;
    //                 q.push({n,node});
    //             }
    //         }
    //     }
    //     return false;
    // }
    // bool cycleDfs(int node,int par)
    // {
    //     vis[node]=1;
    //     for(int n : adj[node])
    //     {
    //         if(!vis[n])
    //         {
    //             if(cycleDfs(n,node)) return true;
    //         }
    //         else if(par!=n)
    //         {
    //             return true;
    //         }
    //     }
    //     return false;
    // }
    // int dp[2][N];
    // int maxlen(vi &v,int prev,int o,int i)
    // {
    //     if(i>=sz(v)) return 0;
    //     if(dp[o][i]!=-1) return dp[o][i];
    //     if(o)
    //     {
    //         int mx=1;
    //         if(prev==-1)
    //         {
    //             mx=max(mx,maxlen(v,v[i],o,i+1)+1);
    //             mx=max(mx,maxlen(v,prev,o,i+1));
    //         }
    //         else
    //         {
    //             if(prev<v[i]) 
    //             {
    //                     mx=max(mx,maxlen(v,v[i],o,i+1)+1);
    //                     mx=max(mx,maxlen(v,prev,o-1,i+1));
    //             }
    //             else
    //             {
    //                 mx=max(mx,maxlen(v,prev,o-1,i+1));
    //             }
    //         }
    //         return dp[o][i]=mx;
    //     }
    //     else
    //     {
    //         int mx=-1;
    //         if(prev==-1)
    //         {
    //             mx=max(mx,maxlen(v,v[i],o,i+1)+1);
    //             mx=max(mx,maxlen(v,prev,o,i+1));
    //         }
    //         else 
    //         {
    //             if(prev<v[i]) 
    //                     mx=max(mx,maxlen(v,v[i],o,i+1)+1);
    //             else
    //                     mx=max(mx,0LL);
    //         }
    //         return dp[o][i]=mx;
    //     }
    // }
    // bool Bipartitebfs(int node)
    // {
    //     color[node]=0;
    //     queue<int> q;
    //     q.push(node);
    //     while(!q.empty())
    //     {
    //         node=q.front();
    //         q.pop();
    //         for(int n : adj[node])
    //         {
    //             if(color[n]==-1)
    //             {
    //                 color[n]=(color[node]^1);
    //                 q.push(n);
    //             }
    //             else if(color[n]==color[node])
    //             {
    //                 return false;
    //             }
    //         }
    //     }
    //     return true;
    // }
    // bool Bipartitedfs(int node,int col)
    // {
    //     color[node]=col;
    //     for(int n : adj[node])
    //     {
    //         if(color[n]==-1)
    //         {
    //             if(!Bipartitedfs(n,col^1)) return false;
    //         }
    //         else if(color[n]==color[node])
    //         {
    //             return false;
    //         }
    //     }
    //     return true;
    // }
    // bool cycleDIRdfs(int node)
    // {
    //     vis[node]=1;
    //     dfsvis[node]=1;

    //     for(int n : adj[node])
    //     {
    //         if(!vis[n])
    //         {
    //             if(cycleDIRdfs(n)) return true;
    //         }
    //         else if(dfsvis[n]) return true;
    //     }
    //     dfsvis[node]=0;
    //     return false;
    // }
    // stack<int> s;
    // void TopoSortDFS(int node)
    // {
    //     vis[node]=1;
    //     for(int n : adj[node])
    //     {
    //         if(!vis[n]) TopoSortDFS(n);
    //     }
    //     s.push(node);
    // }
    // vi dist(N,1e18);
    // void dijkstra(int src)
    // {
    //     priority_queue<pii,vii,greater<pair<int,int>> > pq;
    //     dist[src]=0;
    //     pq.push({0,src});
    //     while(!pq.empty())
    //     {
    //         int d=pq.top().x;
    //         src = pq.top().y;
    //         pq.pop();
    //         for(pii a : adj[src])
    //         {
    //             int node=a.x;
    //             int wt = a.y;
    //             if(d+wt<dist[node])
    //             {
    //                 dist[node]=d+wt;
    //                 pq.push({dist[node],node});
    //             }
    //         }
    //     }
    // }
    int n;
    vi query(int r)
    {
        cout<<"?"<<" "<<r<<endl;
        cout.flush();
        vi v(n);
        cin>>v;
        return v;
    }
    bool isprime(int n)
    {
        int i;
        if(n==1) return false;
        for(i=2;i*i<=n;i++)
        {
            if(n%i==0) return false;
        }
        return true;
    }
    // int bfs(int node,int find)
    // {
    //     queue<pii> q;
    //     q.push({node,0});
    //     vis[node]=1;
    //     while(!q.empty())
    //     {
    //         node=q.front().x;
    //         int dis=q.front().y;
    //         q.pop();
    //         for(int n : adj[node])
    //         {
    //             if(n==find) return dis+1;
    //             else if(!vis[n])
    //             {
    //                 q.push({n,dis+1});
    //                 vis[n]=1;
    //             }
    //         }
    //     }
    //     return -1;
    // }
    // void dfs(int node,int &cntv,int &cnte)
    // {
    //     vis[node]=1;
    //     cntv++;
    //     cnte+=sz(adj[node]);
    //     for(int n : adj[node])
    //     {
    //         if(!vis[n])
    //         {
    //             dfs(n,cntv,cnte);
    //         }
    //     }
    // }
    bool possible(int len,int s,int n)
    {
        int c=1,d=n;
        int mx=0,mn=0,i;
        if((len*(len+1))/2<=s && ((n*(n+1))-(n-len)*(n-len+1))/2>=s)
        {
            return true;
        }
        return false;
    }
    // bool check(string s,string kk,int n,int m)
    // {
    //     int i,j;
    //     int ans1=0;
    //     fo(i,0,n-m+1)
    //     {
    //         int f=0;
    //         fo(j,0,m)
    //         {
    //             if(s[i+j]!=kk[j])
    //             {
    //                     f=1;
    //                     break;
    //             }
    //         }
    //         if(!f) ans1++;
    //     }
    //     if(ans1==1) return true;
    //     return false;
    // }
    // int merge(vi &v,int st,int mid,int en)
    // {
    //     int i=st,j=mid,k=0;
    //     vi temp(en-st+1);
    //     int cnt=0;
    //     while(i<mid && j<=en)
    //     {
    //         if(v[i]<v[j])
    //         {
    //             cnt+=(en-j+1)*v[i];
    //             temp[k++]=v[i++];
    //         }
    //         else
    //         {
    //             temp[k++]=v[j++];
    //         }
    //     }
    //     while(i<mid) temp[k++]=v[i++];
    //     while(j<=en) temp[k++]=v[j++];
    //     k=0;
    //     fo(i,st,en+1)
    //     {
    //         v[i]=temp[k++];
    //     }
    //     return cnt;
    // }
    // int count_of_inversions(vi &v,int st,int en)
    // {
    //     if(en<=st) return 0;
    //     int mid=(st+en)/2;
    //     int lefcnt=count_of_inversions(v,st,mid);
    //     int ricnt=count_of_inversions(v,mid+1,en);
    //     int mgcnt=merge(v,st,mid+1,en);
    //     return lefcnt+ricnt+mgcnt;
    // }
    string lcs(string a,string b,int n,int m)
    {
        int dp[n+1][m+1];
        for(int i=0;i<n+1;i++)
        {
            for(int j=0;j<m+1;j++)
            {
                if(i==0 || j==0) dp[i][j]=0;
            }
        }
        for(int i=1;i<n+1;i++)
        {
            for(int j=1;j<m+1;j++)
            {
                if(a[i-1]==b[j-1])
                {
                    dp[i][j]=dp[i-1][j-1]+1;
                }
                else
                {
                    dp[i][j]=max(dp[i-1][j],dp[i][j-1]);
                }
            }
        }
        int i=n,j=m;
        string s;
        while(i>0 && j>0)
        {
            if(a[i-1]==b[j-1])
            {
                s.pb(a[i-1]);
                i--;
                j--;
            }
            else
            {
                if(dp[i][j-1]>dp[i-1][j])
                {
                    j--;
                }
                else
                {
                    i--;
                }
            }
        }
        reverse(all(s));
        return s;

    }
    // int a[11][11];
    // int ans[11][11];
    // int dx[]={1,-1,0,0};
    // int dy[]={0,0,-1,1};
    // void RatinMaze(int n,int aa,int b)
    // {
    //     if(aa==n-1 && b==n-1)
    //     {
    //         ans[n-1][n-1]=1;
    //         for(int i=0;i<n;i++)
    //         {
    //             for(int j=0;j<n;j++)
    //             {
    //                 cout<<ans[i][j]<<" ";
    //             }
    //             cout<<endl;
    //         }
    //         ans[n-1][n-1]=0;
    //         cout<<endl;
    //         return;
    //     }
    //     int i;
    //     ans[aa][b]=1;
    //     fo(i,0,4)
    //     {
           
    //         int xx=aa+dx[i];
    //         int yy=b+dy[i];
    //         if(xx>=0 && xx<n && yy>=0 && yy<n)
    //         {
    //             if(ans[xx][yy]==0 && a[xx][yy]==1)
    //             {
                   
    //                 RatinMaze(n,xx,yy);
                    
    //             }
    //         }
    //     }
    //     // a[aa][b]=0;
    //     ans[aa][b]=0;
    // }
    // vi adj[105];
    // int mx=0;
    // int p;
    // void dfs(int node,int c=0)
    // {
    //     if(node==p && c>0) 
    //     {
    //         mx=max(mx,c);
    //         return;
    //     }
    //     for(int n:adj[node])
    //     {
    //         dfs(n,c+1);
    //     }
    // }
    // int dp[(int)2e5+5][3];
    // int max_len(int n,vi &v,vi last,int s=0)
    // {
    //     if(n==0) return 0;
    //     if(dp[n][s]!=-1) return dp[n][s];
    //     int mx=0;
    //     int i,f=1;
    //     fo(i,0,sz(last))  if(last[i]==v[n-1]) f=0;
    //     if(f)
    //     {
    //         if(s==0)
    //         {
    //             last.pb(v[n-1]);
    //             mx=max(mx,max_len(n-1,v,last,s)+1);
    //             last.pop_back();
    //             mx=max(mx,max_len(n-1,v,last,s+1));
    //         }
    //         else if(s==1)
    //         {
    //             mx=max(mx,max_len(n-1,v,last,s));
    //             last.pb(v[n-1]);
    //             mx=max(mx,max_len(n-1,v,last,s+1)+1);
    //             last.pop_back();
    //         }
    //         else if(s==2)
    //         {
    //             last.pb(v[n-1]);
    //             mx=max(mx,max_len(n-1,v,last,s)+1);
    //             last.pop_back();
    //         }
    //     }
    //     else
    //     {
    //         if(s==0)
    //         {
    //            mx=max(mx,max_len(n-1,v,last,s+1));                
    //         }
    //         else if(s==1)
    //         {
    //             mx=max(mx,max_len(n-1,v,last,s));
    //         }
    //         else if(s==2)
    //         {
    //             return dp[n][s]=0;
    //         }
    //     }
    //     return dp[n][s]=mx;
    // }
    // vi adj[N];
    // int vis[N],cnt[N];
    // map<int,int> mm;
    // vi vv;
    // void dfs(int n,int c=0)
    // {
    //     vis[n]=1;
    //     mm[n]=c;
    //     vv.pb(n);
    //     for(int node : adj[n])
    //     {
    //         if(!vis[node])
    //         {
    //             dfs(node,c+1);
    //             cnt[n]+=cnt[node];
    //         }
    //     }
    //     cnt[n]++;

    // }
    // bool comp(pii a,pii b)
    // {
    //   if(a.x==b.x) return a.y<b.y;
    //   return a.x<b.x;
    // }
    // int dp[1001][1001][2];
    // int Planes(int n,int k,int dir,int l)
    // {
    //     if(k==1) return 0;
    //     if(n<0 || n>=l) return 0;
    //     if(dp[n][k][dir]!=-1) return dp[n][k][dir];
    //     dp[n][k][dir]=0;
    //     dp[n][k][dir]+=1;
    //     if(dir==0)
    //     {
    //         dp[n][k][dir]+=Planes(n-1,k-1,dir^1,l);
    //         dp[n][k][dir]%=MOD;
    //         dp[n][k][dir]+=Planes(n+1,k,dir,l);
    //         dp[n][k][dir]%=MOD;
    //     }
    //     else
    //     {
    //         dp[n][k][dir]+=Planes(n+1,k-1,dir^1,l);
    //         dp[n][k][dir]%=MOD;
    //         dp[n][k][dir]+=Planes(n-1,k,dir,l);
    //         dp[n][k][dir]%=MOD;
    //     }
    //     return dp[n][k][dir];
    // }
    // int dp[1001];
    // int cbst(int n)
    // {
    //     if(n<=1) return 1;
    //     if(dp[n]!=-1) return dp[n];
    //     dp[n]=0;
    //     int k;
    //     fo(k,1,n+1)
    //     {
    //         dp[n]+=cbst(k-1)*cbst(n-k);
    //     }
    //     return dp[n];
    // }
    // int minUnfair(vi &v,int k,int n,vi &e)
    // {
    //     if(k==0) {return 0;}
    //     if(n==0 && k>0) return INT_MAX;

    //     int mn=1e18;
    //     e.pb(v[n-1]);
    //     int f=0,i;
    //     fo(i,0,sz(e)-1) f+=abs(e[i]-v[n-1]); 
    //     mn=min(mn,minUnfair(v,k-1,n-1,e)+f);
    //     e.pop_back();
    //     mn=min(mn,minUnfair(v,k,n-1,e));
    //     return mn;
    // }
    // int dp[31][11][2];
    // int max_profit(vi &v,int i,int n,int k,int g=0)
    // {
    //     if(i==n) 
    //     {
    //         return 0;
    //     }
    //     if(dp[i][k][g]!=-1) return dp[i][k][g];
    //     int mx=max_profit(v,i+1,n,k,g);
    //     if(g==1)
    //     {
    //         mx=max(mx,max_profit(v,i+1,n,k-1,0)+v[i]);
    //     }
    //     else
    //     {
    //         if(k>0) mx=max(mx,max_profit(v,i+1,n,k,1)-v[i]);
    //     }
    //     return dp[i][k][g]=mx;
    // }
    // int dp[10001][5*1001];
    // int min_sal(vii &p,int i,int n,int dif=0)
    // {
    //     if(i==n) return 0;
    //     if(dp[i][dif]!=-1) return dp[i][dif];
    //     int mn=1e18;
    //     if(dif==0)
    //     {
    //         mn=min(mn,min_sal(p,i+1,n,dif+1)+p[i].y);
    //     }
    //     else if(dif==n-i)
    //     {
    //         mn=min(mn,min_sal(p,i+1,n,dif-1)+p[i].x);
    //     }
    //     else
    //     {
    //         mn=min(min_sal(p,i+1,n,dif-1)+p[i].x,min_sal(p,i+1,n,dif+1)+p[i].y);
    //     }
    //     return dp[i][dif]=mn;
    // }
    int dp[40][40];
    int num_square_brackets(string &s,int i,int dif,int n)
    {
        if(i==n && dif==0) return 1;
        if(i==n) return 0;
        if(dp[i][dif]!=-1) return dp[i][dif];
        int num=0;
        if(s[i]=='1')
        {
            if(dif>0)
            {
                s[i]=')';
                num+=num_square_brackets(s,i+1,dif-1,n);
                s[i]='(';
                num+=num_square_brackets(s,i+1,dif+1,n);
            }
            else
            {
                s[i]='(';
                num+=num_square_brackets(s,i+1,dif+1,n);

            }
            s[i]='1';
        }
        else
        {
            num+=num_square_brackets(s,i+1,dif+1,n);
        }
        return dp[i][dif]=num;

    }
    map<string,int > m;
    void dis_subseq(string &s,int n,int i,string ans="")
    {
        if(i==n)
        {
            m[ans]++;
            return;
        }
        if(m.count(ans))
        {
            return;
        }
        ans.pb(s[i]);
        dis_subseq(s,n,i+1,ans);
        ans.pop_back();
        dis_subseq(s,n,i+1,ans);
    }
    int mx_vis(int a,int b,int c,int ca=0,int cb=0,int cc=0,int cd=0,int ce=0,int cf=0,int cg=0)
    {
        if(a==0 && b==0 && c==0) return 0;
        int mx=0;
        if(a>0 && ca==0) mx=max(mx,1+mx_vis(a-1,b,c,ca+1,cb,cc,cd,ce,cf,cg));
        if(b>0 && cb==0) mx=max(mx,1+mx_vis(a,b-1,c,ca,cb+1,cc,cd,ce,cf,cg));
        if(c>0 && cc==0) mx=max(mx,1+mx_vis(a,b,c-1,ca,cb,cc+1,cd,ce,cf,cg));
        if(a>0 && b>0 && cd==0) mx=max(mx,1+mx_vis(a-1,b-1,c,ca,cb,cc,cd+1,ce,cf,cg));
        if(a>0 && c>0 && ce==0) mx=max(mx,1+mx_vis(a-1,b,c-1,ca,cb,cc,cd,ce+1,cf,cg));
        if(b>0 && c>0 && cf==0) mx=max(mx,1+mx_vis(a,b-1,c-1,ca,cb,cc,cd,ce,cf+1,cg));
        if(a>0 &&  b>0 && c>0 && cg==0) mx=max(mx,1+mx_vis(a-1,b-1,c-1,ca,cb,cc,cd,ce,cf,cg+1));
        return mx;
    }
    int find_al(int l,int r,string &s,char ch)
    {
        int i;
        if(r>=n || l<0) return -1;
        fo(i,l,r+1)
        {
            if(s[i]==ch) return i;
        }
        return -1;
    }
    bool ok(vi &p)
    {
        int n=p.size();
        if(n<=2) return true;
        if(n>=5) return false;
        int  i,j,k;
        fo(i,0,n)
        {
            fo(j,i+1,n)
            {
                fo(k,j+1,n)
                {
                    if((p[j]>=p[i] && p[j]<=p[k]) || (p[k]<=p[j] && p[j]<=p[i])) return false;
                }
            }
        }
        return true;
    }
    int i;
    int solve(string &s,char c)
    {
        int n=s.length();
        if(n==1)
        {
            if(s[0]==c) return 0;
            return 1;
        }
        string ne,ne2;
        int cnt1=0,cnt2=0;
        fo(i,0,n/2)
        {
            if(s[i]!=c) cnt1++;
            ne.pb(s[i]);
        }
        fo(i,n/2,n)
        {
            if(s[i]!=c) cnt2++;
            ne2.pb(s[i]);
        }
        // cout<<ne<<endl;
        // cout<<min(solve(ne,c+1)+cnt2,solve(ne2,c+1)+cnt1)<<endl;
        return min(solve(ne,c+1)+cnt2,solve(ne2,c+1)+cnt1);
    }
    int binpow(int a, int b) 
    {
        a %= MOD;
        int res = 1;
        while (b > 0) 
        {
            if (b & 1) 
                res = res * a % (MOD);
            a = a * a % (MOD);
            b >>= 1;
        }
        return res;
    }
    int fact[N],invfact[N];
    void factorial()
    {
        int i;
        fact[0]=1;
        for(i=1;i<N;i++)
        {
            fact[i]=i*fact[i-1]%MOD;
        }
        i--;
        invfact[i]=binpow(fact[i],MOD-2);
        for(i--;i>=0;i--)
        {
            invfact[i]=(i+1)*invfact[i+1]%MOD;
        }
    }
    int nCr(int n,int r)
    {
        if(r>n || n<0 || r<0) return 0;
        return fact[n] * invfact[r] % MOD * invfact[n-r] % MOD;
    }
    bool perform(string &s,string &p,int n,int m,int ind)
    {
       int c,i,j,f=0;
       c=1;
       if(c==m) return true;
       rfo(i,ind-1,0)
       {
         if(s[i]==p[c])
         {
            c++;
            if(c==m) return true;
         }
         else break;
       }
       c=1;
       fo(i,ind+1,n)
       {
          if(s[i]==p[c])
          {
            c++;
            if(c==m) return true;
            int k=c;
            rfo(j,i-1,0)
            {
                if(s[j]==p[c])
                {
                    c++;
                    if(c==m) return true;
                }
                else break;
            }
            c=k;
          }
          else
          {
            if(i>ind)
            {
                int k=c;
                rfo(j,i-2,0)
                {
                    if(s[j]==p[c])
                    {
                        c++;
                        if(c==m) return true;
                    }
                    else break;         
                }
                c=k;
                // if(c==m) return true;
                break;
            }
            else break;
          }
       }
       return false;

    }
    // int vis[100];
    // vi adj[100];
    // vnn v[50];
    // // int g[50][50];
    // // vnn ans[50];
    // vi cur;
    // void dfs(int n)
    // {
    //     vis[n]=1;
    //     cur.pb(n);
    //     for(int node: adj[n])
    //     {
    //         if(!vis[node]) dfs(node);
    //     }
    // }
    // vi mm(N,1e9);
    vii adj[N];
    bool comp(pii a,pii b)
    {
        if(a.x!=b.x)
        {
            return a.x<b.x;
        }
        return a.y>b.y;
    }
    signed main()
    {
        thunder;
        #ifndef ONLINE_JUDGE
           freopen("Input.txt","r",stdin);
           freopen("Output.txt","w",stdout);
           freopen("Error.txt","w",stderr);
        #endif
        int t,c,m,b,f,f2,k,t2,t3,i,j,ans1,mnt,mxt,j1,a;
        cin>>t;
        while(t--)
        {
            cin>>n>>k;
            vii v(n);
            fo(i,0,n)
            {
                cin>>a;
                v[i].x=a;
                v[i].y=i+1;
            }
            sort(all(v),comp);
            int mx=-1e16;
            fo(i,1,n)
            {
                mx=max(mx,((v[i].y)*(v[i-1].y))-(k*(v[i].x|v[i-1].x)));
            }
            cout<<mx<<endl;
        }



    }

    

    


    