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>.
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;

/**
 * Created by kirillskiy on 10/12/2016.
 */
public class CountPairsXoringToX {

    static Map<Long, Long> occurences;
    static List<Long> sparce;

    private static long countIndecesXoringToX(int x) {
        long pairs = 0;
        for (int i = 0; i < sparce.size(); i++) {
            long searchingFor = sparce.get(i) ^ x;
            if (occurences.containsKey(searchingFor)) {
                Long occurs = occurences.get(searchingFor);
                if (x != 0) {
                    pairs += occurs * occurences.get(sparce.get(i));
                } else {
                    pairs += occurs * (occurs - 1);
                }
            }
        }
        return pairs / 2;
    }

    private static Map<Long, Long> getInputMap(Long[] input) {
        return Arrays.asList(input).parallelStream()
                .collect(Collectors.groupingBy(Function.identity(), Collectors.reducing(0L, i -> 1L, Long::sum)));
    }


    public static void main(String[] arg) {
        Scanner scanner = new Scanner(System.in);
        int inputSize = scanner.nextInt();
        int x = scanner.nextInt();
        Long[] input = new Long[inputSize];
        for (int i = 0; i < inputSize; i++) {
            input[i] = scanner.nextLong();
        }

        occurences = getInputMap(input);
        sparce = new ArrayList<>(occurences.keySet());

        System.out.println(countIndecesXoringToX(x));
    }

}
