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.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x = sc.nextInt();
        ArrayList<Integer> array = new ArrayList<Integer>();
        for(int i=0; i<n; i++){
            array.add(sc.nextInt());
        }
        Collections.sort(array);
        long count = 0;
        HashMap<String, Boolean> foundPair = new HashMap<String,Boolean>();
        //System.out.println(array);
        for(int i=0; i<array.size(); i++){
            int a = array.get(i);
            int b = x ^ a;
            int bIndex = Collections.binarySearch(array, b);
            if(bIndex >= 0){
                String str = (a > b) ? b + ":" + a : a + ":" + b;
                if(!foundPair.containsKey(str)) {
                    if(a == b){
                        // If both the number are same then all there combinations will be
                        // (n-1) + (n-2) + (n-3) + ..... + 1 = ( ((n-1) * (n-1+1)) / 2)
                        long occ = FindNumberOfOccurrences(array, a);
                        count = count + (((occ-1)*(occ))/2);
                    }
                    else {
                        long occA = FindNumberOfOccurrences(array, a);
                        long occB = FindNumberOfOccurrences(array, b);
                        count = count + (occA * occB);
                    }
                    foundPair.put(str, true);
                    //System.out.println(a + "," + b + "," + i + "," + bIndex + "," + str + ", " + count);
                }
            }
        }
        System.out.println(count);
    }
    
    public static long FindNumberOfOccurrences(ArrayList<Integer> array, int element){
        long occ = 0;
        int start = FindFirstOccurrence(array, element);
        if(start == -1){
            // No element found 
            return 0;
        }
        int end = FindLastOccurrence(array, element);
        occ = end - start + 1;
        return occ;
    }
    
    public static int FindFirstOccurrence(ArrayList<Integer> array, int element){
        int start = 0;
        int end   = array.size() - 1;
        while(end >= start){
            int mid = (start + end) / 2;
            if( ((mid == 0) || (array.get(mid - 1) < element)) && (array.get(mid) == element)){
                return mid;
            }
             // NOTE : if element == array.get(mid) , we update end
            else if(element > array.get(mid)){
                start = mid + 1;
            }
            else {
                end = mid - 1;
            }
        }
        return -1;
    }
    
     public static int FindLastOccurrence(ArrayList<Integer> array, int element){
        int start = 0;
        int end   = array.size() - 1;
        while(end >= start){
            int mid = (start + end) / 2;
            if( ((mid == array.size() - 1) || (array.get(mid + 1) > element)) && (array.get(mid) == element)){
                return mid;
            }
            // NOTE : if element == array.get(mid) , we update start
            else if(element < array.get(mid)){
                end = mid - 1;
            }
            else {
                start = mid + 1;
            }
        }
        return -1;
    }
}