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 java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.util.InputMismatchException;
  
  /**
   * @author ethan55
   */
  public class Solution {
    public static void main(String[] args) {
      TestRunner.run();
    }
  
    public static class TestCase {
      static final boolean MULTIPLE = true;
  
      public void solve(InputReader in, OutputWriter out) {
        int n = in.nextInt();
        int k = in.nextInt();
        long[] nums = in.nextLongArray(n);
        long max = Long.MIN_VALUE;
        for (int i = Math.max(n - 1000, 0); i < nums.length; i++) {
          for (int j = i + 1; j < nums.length; j++) {
            max = Math.max(max, (i + 1L) * (j + 1) - k * (nums[i] | nums[j]));
          }
        }
        out.println(max);
      }
    }
  
    public static class TestRunner {
  
      public static void run() {
        InputReader in = new InputReader(System.in);
        try (OutputWriter out = new OutputWriter(System.out)) {
          int testCases = TestCase.MULTIPLE ? in.nextInt() : 1;
          for (int i = 1; i <= testCases; i++) {
            new TestCase().solve(in, out);
          }
        }
      }
  
    }
  
    public static class InputReader {
      private final InputStream inputStream;
      private final byte[] inputBuffer = new byte[1024];
      private int bytesRead = 0;
      private int inputBufferIndex = 0;
  
      public InputReader(InputStream inputStream) {
        this.inputStream = inputStream;
      }
  
      private int readByte() {
        if (bytesRead == -1) {
          throw new InputMismatchException();
        }
        if (inputBufferIndex >= bytesRead) {
          inputBufferIndex = 0;
          try {
            bytesRead = inputStream.read(inputBuffer);
          } catch (IOException e) {
            throw new InputMismatchException();
          }
          if (bytesRead <= 0) {
            return -1;
          }
        }
        return inputBuffer[inputBufferIndex++];
      }
  
      public int nextInt() {
        return (int) nextLong();
      }
  
      public long nextLong() {
        long num = 0;
        int b;
        boolean minus = false;
        do {
          b = readByte();
        } while (b != -1 && !((b >= '0' && b <= '9') || b == '-'));
        if (b == '-') {
          minus = true;
          b = readByte();
        }
  
        while (true) {
          if (b >= '0' && b <= '9') {
            num = num * 10 + (b - '0');
          } else {
            return minus ? -num : num;
          }
          b = readByte();
        }
      }
  
      public long[] nextLongArray(int n) {
        long[] a = new long[n];
        for (int i = 0; i < n; i++) {
          a[i] = nextLong();
        }
        return a;
      }
  
    }
  
    public static class OutputWriter implements AutoCloseable {
      private static final int BUFFER_SIZE = 1 << 13;
      private final byte[] outputBuffer = new byte[BUFFER_SIZE];
      private final OutputStream outputStream;
      private int outputBufferIndex = 0;
  
      public OutputWriter(OutputStream os) {
        this.outputStream = os;
      }
  
      public OutputWriter println(long x) {
        return writeln(x);
      }
  
      public void flush() {
        innerFlush();
        try {
          outputStream.flush();
        } catch (IOException e) {
          throw new IllegalStateException("Failed to flush");
        }
      }
  
      private OutputWriter write(byte b) {
        outputBuffer[outputBufferIndex++] = b;
        if (outputBufferIndex == BUFFER_SIZE) {
          innerFlush();
        }
        return this;
      }
  
      private OutputWriter write(String s) {
        s.chars()
            .forEach(
                c -> {
                  outputBuffer[outputBufferIndex++] = (byte) c;
                  if (outputBufferIndex == BUFFER_SIZE) {
                    innerFlush();
                  }
                });
        return this;
      }
  
      private static int countDigits(long l) {
        if (l >= 1000000000000000000L) {
          return 19;
        }
        if (l >= 100000000000000000L) {
          return 18;
        }
        if (l >= 10000000000000000L) {
          return 17;
        }
        if (l >= 1000000000000000L) {
          return 16;
        }
        if (l >= 100000000000000L) {
          return 15;
        }
        if (l >= 10000000000000L) {
          return 14;
        }
        if (l >= 1000000000000L) {
          return 13;
        }
        if (l >= 100000000000L) {
          return 12;
        }
        if (l >= 10000000000L) {
          return 11;
        }
        if (l >= 1000000000L) {
          return 10;
        }
        if (l >= 100000000L) {
          return 9;
        }
        if (l >= 10000000L) {
          return 8;
        }
        if (l >= 1000000L) {
          return 7;
        }
        if (l >= 100000L) {
          return 6;
        }
        if (l >= 10000L) {
          return 5;
        }
        if (l >= 1000L) {
          return 4;
        }
        if (l >= 100L) {
          return 3;
        }
        if (l >= 10L) {
          return 2;
        }
        return 1;
      }
  
      private OutputWriter write(long x) {
        if (x == Long.MIN_VALUE) {
          return write("" + x);
        }
        if (outputBufferIndex + 21 >= BUFFER_SIZE) {
          innerFlush();
        }
        if (x < 0) {
          write((byte) '-');
          x = -x;
        }
        int d = countDigits(x);
        for (int i = outputBufferIndex + d - 1; i >= outputBufferIndex; i--) {
          outputBuffer[i] = (byte) ('0' + x % 10);
          x /= 10;
        }
        outputBufferIndex += d;
        return this;
      }
  
      private OutputWriter writeln(long x) {
        return write(x).writeln();
      }
  
      private OutputWriter writeln() {
        return write((byte) '\n');
      }
  
      private void innerFlush() {
        try {
          outputStream.write(outputBuffer, 0, outputBufferIndex);
          outputBufferIndex = 0;
        } catch (IOException e) {
          throw new IllegalStateException("Failed to inner flush");
        }
      }
  
      @Override
      public void close() {
        flush();
      }
    }
  }