There are different ways to implement it. I maintained half-closed interval [l, r). So initially l = 0, r = 0 — empty interval. You can see my submission

Lets q[] be your queries. Then you can set MS=q[0].left and MR=q[0].right. Then you just need one extra loop before the main MO's algorithm part that add all numbers in [ML; MR]. You can look at one of my last submission.

PS: Here's a link

Here's how it worked down for me as I was too trying the same for past few hours(opening everybody's code and trying to get that how did pointer movement actually worked out.)

Let's suppose , for range [L,R] we have what is the answer up till now and cnt[i] stores what is the number of times that i XOR has occurred in current range.

I am taking closed interval [L,R] means for the current range we have all the XOR prefixes included from prefix[L-1] to prefix[R] (assuming 1 indexed).

Now , considering the reason for cnt[0] = 1 that you mentioned above.

Suppose , you have this as test case.

1 1 1

1

1 1

So, while moving your pointer towards right you will add current_answer += cnt[K ^ prefix[currR]]; and since K ^ prefix[currR] (for currR = 1) = 0 , so the correct answer upto this state must come equal to 1. (Thus , it is marked initially by some people as cnt[0] = 1) .

What if we don't actually want to avoid this ? Just start your currR pointer from a step back.

Now , considering four conditions for MO's algoithm.

int currL = 1 ,currR = 0 ; int L = query[i].L ; int R = query[i].R ;

while(currR < R)
{
	currR++; 	
	current_answer += cnt[prefix[currR] ^ K]; 
	cnt[prefix[currR]]++; 
}

while(currR > R)
{
	cnt[prefix[currR]]--;
	current_answer -= cnt[prefix[currR] ^ K];
	currR--; 
}

while(currL < L)
{
	cnt[prefix[currL-1]]--;
	current_answer -= cnt[prefix[currL-1] ^ K] ;
        currL++;
}

while(currL > L)
{
        currL--;
	current_answer += cnt[prefix[currL-1] ^ K];
	cnt[prefix[currL-1]]++;
}

Finally , that crooked up my mind is what is the need for including the prefix[L-1] to prefix[R] is:

Suppose you move your right pointer towards right. Now , your current answer would modify as adding of new sub arrays that end at this current right position .

So, let's suppose that you are searching for index such that a[index] ^ a[index+1] .. ^ a[R] = K for the current window which is basically searching for position such that prefix[R] ^ prefix[position] = K and index can thus start from position+1 .

Eventually it means, you want to count all the XOR'S = prefix[position] so that a[position+1] ^ a[position+2] .. ^ a[R] = K . Thus, minimum value of position+1 can be L ,hence position must be L-1 . Thus there's a need to include prefixes from [L-1] to [R] .

Here's my submission.

Happy Coding :)