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;
using System.Linq;
using System.Text;
using static System.Math;

class Program{
    static int n;
    static long[] a;
    static long mod = (long)1e9 + 7;

    static void Main(){
        n = int.Parse(Console.ReadLine());
        a = Console.ReadLine().Split().Select(long.Parse).ToArray();
        long[] xor = new long[n + 1]; //累積xor
        for (int i = 1;i <= n;i++)
            xor[i] = xor[i - 1] ^ a[i - 1];
        
        if (xor[n] == 0){ //全体のxorが0
            long ans = 0;
            int c = 0;
            for (int i = 1;i < n;i++)
                if (xor[i] == 0) c++;
            ans += Pow(2,c); //0|0|0|...

            /* わからん */

            Console.WriteLine(ans);
            return;
        }

        long x = xor[n];
        List<long> ls = new List<long>();
        for (int i = 1;i <= n;i++)
            if (xor[i] == 0 || xor[i] == x)
                ls.Add(xor[i]);
        long[,] dp = new long[ls.Count + 1,2];
        dp[0,1] = 1;
        for (int i = 1;i <= ls.Count;i++){
            if (ls[i - 1] == x){
                dp[i,0] = (dp[i-1,0] + dp[i,1]) % mod;
                dp[i,1] = dp[i-1,1];
            }
            else{
                dp[i,0] = dp[i-1,0];
                dp[i,1] = (dp[i-1,1] + dp[i-1,0]) % mod;
            }
        }
        Console.WriteLine(dp[ls.Count - 1,1]);
    }

    static long Pow(long p,long k){
        p %= mod;
        if (k == 0) return 1;
        if (k == 1) return p;
        long t = Pow(p,k/2);
        if (k % 2 == 0) return t * t % mod;
        return (t * t % mod) * p % mod;
    }
}