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: t = int(input())
  
  for tc in range(t):
  
      n, k = map(int, input().split())
  
      arr = [int(z) for z in input().split()]
  
      left = max(0, n - (2*k)-1)
  
      res = -10**18
  
      for i in range(left, n):
          for j in range(i+1, n):
              r = (i+1) * (j+1) - (k * (arr[i] | arr[j]))
  
              res = max(res, r)
  
      print(res)
  
      # less = []; more = []
      # for i in range(n):
      #
      #     if arr[i] < i+1:
      #         less.append(i)
      #     else:
      #         more.append([arr[i], i])
      #
      # more1 = []
      # more.sort()
      # for i in more:
      #     more1.append(i[1])
      #
      # less1 = less[::-1]
      # comb = less1 + more1
      #
      # m1 = comb[0]
      #
      #
      # res = -10**18
      #
      # for i in range(1, len(comb)):
      #     m2 = comb[i]
      #     res = max(res, ((m1+1) * (m2+1) - (k * (arr[m1] | arr[m2]))))
      #
      # print(res)
      #
      # # arr2 = sorted(arr)
      # #
      # # m1 = arr2[0]; m2 = arr2[1]
      # #
      # # for i in reversed(range(n)):
      # #     if arr[i] == m1:
      # #         m1d = i+1
      # #         break
      # #
      # # for i in reversed(range(n)):
      # #     if arr[i] == m2 and i+1 != m1d:
      # #         m2d = i+1
      # #         break
      # #
      # # print(m1d * m2d - k * (m1 | m2))
      #
      # # arr1 = []
      # # for i in range(n):
      # #     arr1.append([i, i - arr[i] + 1, arr[i]])
      # #
      # # arr1.sort()
      # #
      # # a, b, c = map(int, arr1[-1])
      # # d, e, f = map(int, arr1[-2])
      # #
      # # print(arr1)
      # #
      # print(a * d - (k * (c | f)))