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.io.*;
public class TestClass {
	
	static PrintWriter out = new PrintWriter(System.out);
    public static void main(String args[] ) throws Exception {
        
        BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
        String s[] = in.readLine().split(" ");
        int n = Integer.parseInt(s[0]);
        int x = Integer.parseInt(s[1]);
        String s1[]  = in.readLine().split(" ");
        int a[] = new int[n];
        for(int i=0;i<n;i++)
        {
        	a[i] = Integer.parseInt(s1[i]);
        }
        Arrays.sort(a);
        long cnt=0;
        for(int i=0;i<n;i++)
        {
        	//int p = (int)t.ceiling(x^a[i]);
        	//int q = (int)t.floor(x^a[i]);
        	int p = binarySearchFirstOccurrence(a, x^a[i]);
        	int q = binarySearchLastOccurrence(a, x^a[i]);
        	//System.out.println(p+" "+q);
        	if(p>=0 )
        	{
        		if(a[i]==a[p])
        		{
        			cnt--;
        		}
        	}
        	if(p==q && p>=0)
        	{
        		cnt++;
        	}
        	else if(p>=0)
        	{
        		cnt+=q-p+1;
        	}
        	
        }
        out.println(cnt/2);
        out.close();
    }
    public static int binarySearchFirstOccurrence(int a[], int x)
    {
        int mid,low=0,high=a.length-1,result = -1;
     
        while(low<=high)
        {
            mid = low + (high - low)/2; 
            if(x==a[mid])
            {
            	result = mid;
            	high = mid-1;
            }
            else if(x<a[mid])
            {
            	high = mid-1;
            }
            else
            {
            	low = mid+1;
            }
     
        }
        return result;
    }    
    public static int binarySearchLastOccurrence(int a[],int x)
    {
    	 int mid,low=0,high=a.length-1,result = -1;
         
         while(low<=high)
         {
             mid = low + (high - low)/2; 
             if(x==a[mid])
             {
             	result = mid;
             	low = mid+1;
             }
             else if(x<a[mid])
             {
             	high = mid-1;
             }
             else
             {
             	low = mid+1;
             }
      
         }
         return result;
    }
}