Problem:
Score : 800 points

Problem Statement

The beauty of a sequence a of length n is defined as a_1 \oplus \cdots \oplus a_n, where \oplus denotes the bitwise exclusive or (XOR).

You are given a sequence A of length N.
Snuke will insert zero or more partitions in A to divide it into some number of non-empty contiguous subsequences.

There are 2^{N-1} possible ways to insert partitions.
How many of them divide A into sequences whose beauties are all equal? Find this count modulo 10^{9}+7.

Constraints

All values in input are integers.

1 \leq N \leq 5 \times 10^5

0 \leq A_i < 2^{20}

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \ldots A_{N}

Output

Print the answer.

Sample Input 1

3
1 2 3

Sample Output 1

3

Four ways of dividing A shown below satisfy the condition. The condition is not satisfied only if A is divided into (1),(2),(3).

(1,2,3)

(1),(2,3)

(1,2),(3)

Sample Input 2

3
1 2 2

Sample Output 2

1

Sample Input 3

32
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Sample Output 3

147483634

Find the count modulo 10^{9}+7.

Sample Input 4

24
1 2 5 3 3 6 1 1 8 8 0 3 3 4 6 6 4 0 7 2 5 4 6 2

Sample Output 4

292

Solution in C# (Mono 4.6.2.0) (judge verdict: Wrong Answer)

using System;
using System.Collections.Generic;
class Program
    {
    	static void Main(string[] args)
    	{
            int n = int.Parse(Console.ReadLine());
            string[] s = Console.ReadLine().Split(' ');
            long[] a = new long[n];
            for (int i=0; i<n; i++) a[i] = long.Parse(s[i]);
            
            Dictionary<long, long> count = new Dictionary<long, long>();
            Dictionary<long, long> ans   = new Dictionary<long, long>();
            long aSum = 0;
            for (int i=0; i<n; i++)
            {
                aSum = aSum ^ a[i];
                if (count.ContainsKey(aSum)) count[aSum]++;
                else count.Add(aSum, 1);
                if (aSum == 0)
                {
                    foreach (long key in count.Keys)
                    {
                        if (ans.ContainsKey(key))
                        {
                            ans[key] *= count[key] + 1;
                            ans[key] %= (long)1000000007;
                        }
                        else ans.Add(key, count[key] + 1);
                    }
                    count = new Dictionary<long, long>();
                }
            }
            if (aSum != 0)
            {
                if (ans.ContainsKey(aSum)) Console.WriteLine(ans[aSum]);
                else Console.WriteLine(1);
            }
            else
            {
                long ans1 = 0;
                foreach(long key in ans.Keys)
                {
                    if (key == 0) ans1 += ans[key] / 2;
                    else ans1 += ans[key] - 1;
                    Console.Error.WriteLine(key + " " + ans[key]);
                }
                Console.WriteLine(ans1);
            }
        }
    }