One day, ZS the Coder wrote down an array of integers a with elements a1, a2, ..., an.

A subarray of the array a is a sequence al, al + 1, ..., ar for some integers (l, r) such that 1 ≤ l ≤ r ≤ n. ZS the Coder thinks that a subarray of a is beautiful if the bitwise xor of all the elements in the subarray is at least k.

Help ZS the Coder find the number of beautiful subarrays of a!

Input

The first line contains two integers n and k (1 ≤ n ≤ 106, 1 ≤ k ≤ 109) — the number of elements in the array a and the value of the parameter k.

The second line contains n integers ai (0 ≤ ai ≤ 109) — the elements of the array a.

Output

Print the only integer c — the number of beautiful subarrays of the array a.

Examples

Input

3 1
1 2 3


Output

5


Input

3 2
1 2 3


Output

3


Input

3 3
1 2 3


Output

2
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.StringTokenizer;

public class Main {
	public static void main(String[] args) {
		new CF665E().solve();
	}
}

class CF665E {

	InputReader in = new InputReader(System.in);
	PrintWriter out = new PrintWriter(System.out);
	
	Trie tree = new Trie() ;

	void solve() {
		int n = in.nextInt() ;
		int k = in.nextInt() ;
		long res = 0 ;
		tree.clear() ; 
		tree.add(0) ;
		int now = 0 ; 
		for(int i = 0 ; i < n ; i++){
			now ^= in.nextInt() ;
			res += tree.find(now , k) ;
			tree.add(now) ;
		}
        out.println(res) ;
        out.flush() ;
	}
}

class Trie{
	
	final int NODESIZE = 1000001*30 ;
	final int NULL = 0 ;
	int root ;
	int totel ; 
	int[][] next = new int[2][NODESIZE] ;
	int[] cnt = new int[NODESIZE] ;
	
	int newNode(){
		next[0][totel] = next[1][totel] = NULL ;
		cnt[totel] = 0 ;
        return totel++ ; 		
	}
	
	void clear(){
		totel = 0 ;
		root = newNode() ;
	}
	
	void add(int x){
		int now = root ;
		for(int i = 30 ; i >= 0 ; i--){
			int son = ( x & (1<<i) ) > 0 ? 1 : 0 ;
			if(next[son][now] == NULL)
				next[son][now] = newNode() ;
			now = next[son][now] ;
			cnt[now]++ ;
		}
	}
	
	int find(int x , int k){
		int res = 0 ;
		int now = root ;
		for(int i = 30 ; i >= 0 ; i--){
			int bitX = ( x & (1<<i) ) > 0 ? 1 : 0 ;
			int bitK = ( k & (1<<i) ) > 0 ? 1 : 0 ;
			if(bitX == 1 && bitK == 1){
				if(next[0][now] == NULL) return res ;
				else now = next[0][now] ;
			}
			else if(bitX == 0 && bitK == 1){
				if(next[1][now] == NULL) return res ;
				else now = next[1][now] ;
			}
			else if(bitX == 1 && bitK == 0){
				if(next[0][now] != NULL) res += cnt[next[0][now]] ;
				if(next[1][now] == NULL) return res ;
				else now = next[1][now] ;
			}
			else if(bitX == 0 && bitK == 0){
				if(next[1][now] != NULL) res += cnt[next[1][now]] ;
				if(next[0][now] == NULL) return res ;
				else now = next[0][now] ;
			}
		}
		return res + cnt[now] ;
	}

}

class InputReader {
	public BufferedReader reader;
	public StringTokenizer tokenizer;

	public InputReader(InputStream stream) {
		reader = new BufferedReader(new InputStreamReader(stream), 32768);
		tokenizer = null;
	}

	public String next() {
		while (tokenizer == null || !tokenizer.hasMoreTokens()) {
			try {
				tokenizer = new StringTokenizer(reader.readLine());
			} catch (IOException e) {
				throw new RuntimeException(e);
			}
		}
		return tokenizer.nextToken();
	}

	public int nextInt() {
		return Integer.parseInt(next());
	}

	public long nextLong() {
		return Long.parseLong(next());
	}

	public double nextDouble() {
		return Double.parseDouble(next());
	}

	public BigInteger nextBigInteger() {
		return new BigInteger(next());
	}

}
