description: 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.
solution: import sys
  import math
  import heapq
  from collections import defaultdict as dd
  from collections import OrderedDict as od
  from collections import deque
  from itertools import permutations as pp
  from itertools import combinations as cc
  from sys import stdin
  from functools import cmp_to_key
  from functools import lru_cache
  from bisect import bisect_left as bs_l
  from bisect import bisect_right as bs_r
  input = sys.stdin.readline
  mod=10**9+7
  sys.setrecursionlimit(10**5)               
  T=int(input())
  for _ in range(T):
      n,k=map(int,input().split())
      arr=list(map(int,input().split()))
      if n>1000:
          ans=-10**9
          brr=arr[::-1]
          for i in range(1000):
              for j in range(i+1,1000):
                  tmp=(n-i)*(n-j)-k*(brr[i]|brr[j])
                  ans=max(ans,tmp)
          print(ans)
      else:
          ans=-10**9
          for i in range(n):
              for j in range(i+1,n):
                  tmp=(i+1)*(j+1)-k*(arr[i]|arr[j])
                  ans=max(ans,tmp)
          print(ans)
  