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.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;

public class Main {
    
    public static void main(String[] args) throws IOException {
        Reader.init(System.in);
        StringBuilder s=new StringBuilder();
        int n = Reader.nextInt(), x = Reader.nextInt(), arr[] = new int[n], f[] = new int[1000000];
        for(int i = 0; i < n; i++) {
            arr[i] = Reader.nextInt();
            f[arr[i]]++;
        }
        if(x == 0) {
            long cnt = 0;
            boolean[] vis = new boolean[1000000];
            for(int i = 0; i < n; i++)
                if(!vis[arr[i]] && f[arr[i]] > 1) {
                    vis[arr[i]] = true;
                    long cur = 0;
                    while(--f[arr[i]] > 0)
                        cur += (long) f[arr[i]];
                    cnt += cur;
                }
            System.out.println(cnt);
            return;
        }
        long cnt = 0;
        HashMap<Integer, HashSet<Integer>> vis = new HashMap<Integer, HashSet<Integer>>();
        for(int i = 0; i < n; i++)
            if(f[arr[i] ^ x] > 0) {
                if(check(vis, arr[i], arr[i] ^ x)) {
                    poll(vis, arr[i], arr[i] ^ x);
                    cnt += (long) f[arr[i]] * (long) f[arr[i] ^ x];
                }
            }
        s.append(cnt).append('\n');
        System.out.print(s);
    }
    
    static boolean check(HashMap<Integer, HashSet<Integer>> vis, int i, int j) {
        if(!vis.containsKey(i))
            return true;
        if(!vis.get(i).contains(j))
            return true;
        if(!vis.containsKey(j))
            return true;
        if(!vis.get(j).contains(i))
            return true;
        return false;
    }
    
    static void poll(HashMap<Integer, HashSet<Integer>> vis, int i, int j) {
        if(!vis.containsKey(i))
            vis.put(i, new HashSet<Integer>());
        if(!vis.containsKey(j))
            vis.put(j, new HashSet<Integer>());
        vis.get(i).add(j);
        vis.get(j).add(i);
    }
    
}

class Reader {
    
    static StringTokenizer tokenizer;
    static BufferedReader reader;
    
    public static void init(InputStream input) throws UnsupportedEncodingException {
        reader=new BufferedReader(new InputStreamReader(input,"UTF-8"));
        tokenizer=new StringTokenizer("");
    }
    
    public static String next() throws IOException {
        while(!tokenizer.hasMoreTokens())
            tokenizer=new StringTokenizer(reader.readLine());
        return tokenizer.nextToken();
    }
    
    public static String nextLine() throws IOException {
        return reader.readLine();
    }
    
    public static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }
    
    public static double nextDouble() throws IOException {
        return Double.parseDouble(next());
    }
    
    public static long nextLong() throws IOException {
        return Long.parseLong(next());
    }
}