There are some beautiful girls in Arpa’s land as mentioned before.

Once Arpa came up with an obvious problem:

Given an array and a number x, count the number of pairs of indices i, j (1 ≤ i < j ≤ n) such that <image>, where <image> is bitwise xor operation (see notes for explanation).

<image>

Immediately, Mehrdad discovered a terrible solution that nobody trusted. Now Arpa needs your help to implement the solution to that problem.

Input

First line contains two integers n and x (1 ≤ n ≤ 105, 0 ≤ x ≤ 105) — the number of elements in the array and the integer x.

Second line contains n integers a1, a2, ..., an (1 ≤ ai ≤ 105) — the elements of the array.

Output

Print a single integer: the answer to the problem.

Examples

Input

2 3
1 2


Output

1

Input

6 1
5 1 2 3 4 1


Output

2

Note

In the first sample there is only one pair of i = 1 and j = 2. <image> so the answer is 1.

In the second sample the only two pairs are i = 3, j = 4 (since <image>) and i = 1, j = 5 (since <image>).

A bitwise xor takes two bit integers of equal length and performs the logical xor operation on each pair of corresponding bits. The result in each position is 1 if only the first bit is 1 or only the second bit is 1, but will be 0 if both are 0 or both are 1. You can read more about bitwise xor operation here: <https://en.wikipedia.org/wiki/Bitwise_operation#XOR>.
#!/usr/bin/python

import unittest


def find_num_pairs_with_xor_equals_x(n, x, arr):

    num_dict = {}
    num_pairs = 0

    # Iterate over the keys instead of array as array will have
    # duplicates
    for num in arr:
        # ai ^ aj = x ==> ai ^ x = aj.
        # Thus we check if xor of x with current number matches with
        val = num^x
        num_pairs += num_dict.get(val, 0)
        num_dict[num] = num_dict.get(num, 0) + 1

    return num_pairs


def find_num_pairs_with_xor_equals_x_timeout(n, x, arr):

    arr.sort()
    num_pairs = 0

    for index, num in enumerate(arr):
        val = num^x
        # Find if the value is in the array
        for ii, nn in enumerate(arr):
            # If current number is greater than val then we early out
            # there is no point iterating over remaining numbers
            if nn > val:
                break

            # if xor equals the current number then we have a pair
            # given it is not the same number
            if val == nn and index != ii:
                num_pairs += 1


    # Divide into half as we have to return the number of pairs
    #print num_pairs/2
    return num_pairs/2



class TestSamples(unittest.TestCase):

    def test_sample_1(self):
        x = 3
        arr = [1, 2]
        self.assertEquals(find_num_pairs_with_xor_equals_x(len(arr), x, arr), 1)

    def test_sample_2(self):
        x = 1
        arr = [5, 1, 2, 3, 4, 1]
        self.assertEquals(find_num_pairs_with_xor_equals_x(len(arr), x, arr), 2)

    def test_sample_3(self):
        x = 0
        arr = [1, 1]
        self.assertEquals(find_num_pairs_with_xor_equals_x(len(arr), x, arr), 1)

    def test_sample_4(self):
        x = 0
        arr = [1, 1, 1]
        self.assertEquals(find_num_pairs_with_xor_equals_x(len(arr), x, arr), 3)

    def test_sample_5(self):
        x = 0
        arr = [1, 1, 1, 2]
        self.assertEquals(find_num_pairs_with_xor_equals_x(len(arr), x, arr), 3)


    def test_sample_6(self):
        x = 0
        arr = [1, 2, 3, 4]
        self.assertEquals(find_num_pairs_with_xor_equals_x(len(arr), x, arr), 0)


if __name__ == "__main__":
    n, x = map(int, raw_input().split(' '))
    arr = map(int, raw_input().split(' '))

    print find_num_pairs_with_xor_equals_x(n, x, arr)

    #unittest.main()
