There is an integer sequence A of length N.
Find the number of the pairs of integers l and r (1 \leq l \leq r \leq N) that satisfy the following condition:
 - A_l\ xor\ A_{l+1}\ xor\ ...\ xor\ A_r = A_l\ +\ A_{l+1}\ +\ ...\ +\ A_r
Here, xor denotes the bitwise exclusive OR.
Definition of XOR
The XOR of integers c_1, c_2, ..., c_m is defined as follows:
 - Let the XOR be X. In the binary representation of X, the digit in the 2^k's place (0 \leq k; k is an integer) is 1 if there are an odd number of integers among c_1, c_2, ...c_m whose binary representation has 1 in the 2^k's place, and 0 if that number is even.
For example, let us compute the XOR of 3 and 5. The binary representation of 3 is 011, and the binary representation of 5 is 101, thus the XOR has the binary representation 110, that is, the XOR is 6.

-----Constraints-----
 - 1 \leq N \leq 2 \times 10^5
 - 0 \leq A_i < 2^{20}
 - All values in input are integers.

-----Input-----
Input is given from Standard Input in the following format:
N
A_1 A_2 ... A_N

-----Output-----
Print the number of the pairs of integers l and r (1 \leq l \leq r \leq N) that satisfy the condition.

-----Sample Input-----
4
2 5 4 6

-----Sample Output-----
5

(l,r)=(1,1),(2,2),(3,3),(4,4) clearly satisfy the condition.
(l,r)=(1,2) also satisfies the condition, since A_1\ xor\ A_2 = A_1\ +\ A_2 = 7.
There are no other pairs that satisfy the condition, so the answer is 5.

Difficulty: interview

Starter code:

Solutions:
def main():
    ans = 0
    n = int(input())
    A = [int(i) for i in input().split()]+[10**9]

    Sum = 0
    right = 0
    for left in range(n):
        while(right<n):
            if Sum^A[right]  == Sum+A[right]:
                Sum += A[right]
                right += 1
            else:
                break
        ans += right-left
        if left==right:
            right +=1
        else:
            Sum -= A[left]
    print(ans)
main()

n=int(input())
a=list(map(int,input().split()))
l=0
r=1
t=a[0]
ans=0
 
while l<n:
  if r==n:
    ans+=r-l
    l+=1
    continue
  if t+a[r]==t^a[r]:
    t+=a[r]
    r+=1
  else:
    ans+=r-l
    t-=a[l]
    l+=1
print(ans)


def main():
    N = int(input())
    A = list(map(int, input().split()))

    l, r = 1, 0
    t = A[0]
    n = 1
    while l < N:
        if A[l] & t:
            t ^= A[r]
            r += 1
            continue
        t |= A[l]
        l += 1
        n += l - r
    return n

print((main()))


n = int(input())
al = list(map(int, input().split())) 

al.append(0)

res = 0
r = 0
x = 0
y = 0


for l in range(n):
#    print("start",l,r)
    while x == y and r<=n:
        x += al[r]
        y = y ^ al[r]
        r += 1
#        print(x,y)
    r -= 1
    x -= al[r]
    y = y ^ al[r]
#    print(x,y,l,r)    
    res +=r-l
    x -= al[l]
    y = y^ al[l]
    if l ==r:
        r += 1

print(res)

N = int(input())
A = list(map(int, input().split()))

sums = [0] * (N + 1)
xors = [0] * (N + 1)
for i in range(1, N + 1):
    sums[i] = sums[i - 1] + A[i - 1]
    xors[i] = xors[i - 1] ^ A[i - 1]

ans = 0
for i in range(N):
    l = i
    r = N
    while l + 1 < r:
        m = (l + r) // 2
        if sums[m + 1] - sums[i] == xors[m + 1] ^ xors[i]:
            l = m
        else:
            r = m
    ans += l - i + 1
print(ans)

N=int(input())
A=list(map(int,input().split()))

to = [0]*N

for i in range(N-1):
  if i == 0:
    SUM = A[i]
  else:
    SUM -= A[i-1]
  for j in range(min(to[i-1]+1,N-1),N):
    if SUM+A[j] != SUM^A[j]:
      to[i]=j-1
      break
    if j == N-1:
      to[i] = j
      break
    SUM += A[j]
  
print(sum([max(0,to[i]-i) for i in range(N)])+N)

n = int(input())
a = list(map(int, input().split()))

cnt, su, r = 0, 0, 0
for l in range(n):
    while r < n and su + a[r] == su ^ a[r]:
        su += a[r]
        r += 1
    cnt += r - l
    if l == r:
        r += 1
    else:
        su -= a[l]
print(cnt)


n = int(input())
A = tuple(map(int, input().split()))
c = 0
s = 0
r = 0
for l in range(n):
    while r < n and A[r] ^ s == A[r] + s:
        s = A[r] + s
        r += 1

    c += r- l
    if l == r:
        r += 1
    s -= A[l]

print(c)



def submit():
    n = int(input())
    a = [int(e) for e in input().split()]

    l, r = 0, 0
    ans = 0
    curr_xor = 0
    curr_sum = 0
    while r < n:
        curr_xor = curr_xor ^ a[r]
        curr_sum = curr_sum + a[r]

        # 今のrで実現する最左のlを求める
        while curr_xor != curr_sum:
            curr_xor = curr_xor ^ a[l]
            curr_sum = curr_sum - a[l]
            l += 1
            # 最悪でもr == lで止まる
        ans += r - l + 1
        # rを動かす
        r += 1

    print(ans)


submit()


n = int(input())
a = list(map(int, input().split()))

s = [0] * n
t = [0] * n

s[0] = a[0]
t[0] = a[0]

for i in range(1, n):
    s[i] = s[i-1] + a[i]
    t[i] = t[i-1] ^ a[i]

s = [0] + s
t = [0] + t 

ans = 0
#print(s, t)

l = 1
r = l
while l < n+1:
    #print(l, r)
    if s[r] - s[l-1] == t[r] ^ t[l-1]:
        while True:
            #print(l, r, s[r] - s[l-1], t[r] ^ t[l-1])
            if s[r] - s[l-1] == t[r] ^ t[l-1]:
                r += 1
                if r > n:
                    ans += r - l
                    r = n
                    break
            else:
                ans += r - l 
                break
    else:
        while True:
            #print(l, r, s[r] - s[l-1], t[r] ^ t[l-1])
            if s[r] - s[l-1] == t[r] ^ t[l-1]:
                ans += r - l + 1
                break
            else:
                r -= 1
                if r == l:
                    ans += 1
                    r = l + 1
                    break

    l += 1

print(ans)

n = int(input())
a = list(map(int,input().split()))

right = 0
sum = 0
ans = 0

for left in range(n):
    while right < n and sum^a[right] == sum+a[right]:
        sum += a[right]
        right += 1
    ans += right-left
    if right == left:
        right += 1
    else:
        sum -= a[left]

print(ans)


n=int(input())
a=list(map(int,input().split()))
l=0
r=1
t=a[0]
ans=0
 
while l<n:
  if r==n:
    ans+=r-l
    l+=1
    continue
  if t+a[r]==t^a[r]:
    t+=a[r]
    r+=1
  else:
    ans+=r-l
    t-=a[l]
    l+=1
print(ans)

n = int(input())
A = list(map(int,input().split()))

ans = 0
l = 0
r = 0
bit = A[0]
total = A[0]

while True:  
  if bit == total:
    ans += r-l+1
    r += 1
    if r == n:
      break
    total += A[r]
    bit ^= A[r]
  else:
    total -= A[l]
    bit ^= A[l]
    l += 1
      
print(ans)      

N = int(input())
ARR = list(map(int,input().split()))
def calculate(n,arr):
    right = 0
    sum = arr[0]
    result = 0

    for left in range(0,n):
        while (right + 1 < n) and ( (sum + arr[right+1]) == (sum ^ arr[right+1]) ):
            right = right + 1
            sum = sum + arr[right]

        result = result + right - left + 1
        sum = sum - arr[left]

    print(result)

calculate(N,ARR)

n = int(input())
a = list(map(int,input().split()))
count = 0
r = 1
l = 0
now = a[0]
while l < n:

    while True:
        if r < n and now + a[r] == now^a[r]:
            now += a[r]
            count += r-l
            r += 1
        else:
            break
    if l == r:
        now = a[l]
        r += 1
    elif l < n:
        now -= a[l]
        l += 1
print(count+n)

n = int(input())
a = [int(i) for i in input().split()]
s = xor = 0
right = 0
ans = 0
for left in range(n):
    while right < n and s + a[right] == xor ^ a[right]:
        s += a[right]
        xor ^= a[right]
        right += 1
    ans += right - left
    if left == right: right += 1
    else:
        s -= a[left]
        xor ^= a[left]
print(ans)

N = int(input())
A = list(map(int, input().split()))
res = 0
ans = 0
right = 0
for left in range(N):
    while right < N and (res ^ A[right]) == res + A[right]:
        res += A[right]
        right += 1
    ans += (right - left)
    if left == right:
        right += 1
    res -= A[left]
print(ans)

nim =int(input())
mike = list(map(int,input().split()))

S = [0]
X = [0]
for a in mike:
    S.append(S[-1]+a)
    X.append(X[-1]^a)

l,r = 1,1
result = 0
p = 1
while r <= nim:
    if S[r]-S[l-1] == X[r]^X[l-1]:
        if p==0:
            result -= (r-l)*(r-l+1)//2
        r += 1
        p = 1
    else:
        if p ==1:
            result += (r-l)*(r-l+1)//2
        l += 1
        p = 0
result += (r-l)*(r-l+1)//2
print(result)

n = int(input())
a = list(map(int, input().split()))
r = 0
ans = 0
s = 0
xor = 0

for i in range(n):
    while r < n:
        if xor ^ a[r] == s + a[r]:
            xor = xor ^ a[r]
            s += a[r]
            r += 1
            ans += (r-i)
        else:
            xor = xor ^ a[i]
            s -= a[i]
            break

print(ans)


N = int(input())
ARR = list(map(int,input().split()))
def calculate(n, arr):
    result = 0
    right = 0
    sum = arr[0]
    for left in range(0, n):
        while right+1 < n:
            if sum ^ arr[right+1] == (sum + arr[right+1]):
                right = right + 1
                sum = sum + arr[right]
            else:
                break
        result = result + right - left + 1
        sum = sum - arr[left]
    print(result)

calculate(N, ARR)


n=int(input())
a=list(map(int,input().split()))
left=0
ans=0
xor_sum=0
normal_sum=0
for right,b in enumerate(a):
	xor_sum^=b
	normal_sum+=b
	while xor_sum<normal_sum:
		xor_sum^=a[left]
		normal_sum-=a[left]
		left+=1
	ans+=right-left+1
print(ans)


from copy import deepcopy
from operator import add, sub

class TwoPointers:
    def __init__(self, cond, init=0, right=add, left=sub):
        self.cond = cond
        self.init = init
        self.next_right = right
        self.next_left = left
    
    def __call__(self, A, uniq=True):
        cond = self.cond
        next_right, next_left = self.next_right, self.next_left
        s = deepcopy(self.init)
        n = len(A)
        X = {}
        r = 0
        for l in range(n):
            if not uniq:
                X[l] = r
            while r < n and cond(s, A[r]):
                s = next_right(s, A[r])
                r += 1
                X[l] = r
            if l == r:
                r += 1
            else:
                s = next_left(s, A[l]) if l+1 != r else deepcopy(self.init)
        return list(X.items())
    
    def maximum(self, A):
        X = self.__call__(A)
        return max(r-l for l, r in X) if X else 0
    
    def count(self, A):
        X = self.__call__(A, False)
        return sum(r-l for l, r in X)

n, *A = map(int, open(0).read().split())
print(TwoPointers(lambda s, n: s + n == s ^ n).count(A))

N = int(input())
A = list(map(int,input().split()))

left = 0
right = 0
ans = 0
tmp = 0

for left in range(N):
    while right < N and tmp + A[right] == tmp ^ A[right]:
        tmp += A[right]
        right += 1
        
    ans += right - left
    
    if right == left:
        right += 1
    else:
        tmp -= A[left]
        
print(ans)

N = int(input())
numbers = list(map(int, input().split()))

summ, right, left = 0, 0, 0
ans = 0

for left in range(N):
    while (right < N and (summ + numbers[right]) == (summ ^ numbers[right])):
        summ += numbers[right]
        right += 1
    
    ans += right - left
    
    
    if (right == left):
        right += 1
    
    else:
        summ -= numbers[left]
        

print(ans)

N = int(input())
A = list(map(int, input().split()))

ans = 0
w_xor,w_sum = A[0],A[0]
l,r = 0,0

while l < N and r < N:
  #print(l,r,w_xor, w_sum)

  if w_xor == w_sum:
    if r < N-1:
    #print(l,r)
      r += 1
      w_xor = w_xor ^ A[r]
      w_sum = w_sum + A[r]
      continue
    else:
      ans += 1+r-l
  else:
    # l,r-1、までがマッチしてたということなので1小さい
    ans += r-l
  w_xor = w_xor ^ A[l] 
  w_sum = w_sum - A[l]
  l += 1
  
print(ans)

#!/usr/bin python3
# -*- coding: utf-8 -*-

############################################
# しゃくとり法
############################################
# 区間において単調増加となるものの個数　ABC038_c
############################################

def main():
    N = int(input())
    A = list(map(int, input().split()))
##
    ret = 0
    right = 0
    tot = 0
    for left in range(0,N):
        while (right < N and ((tot ^ A[right] == tot + A[right]) or left == right)):   #####条件
            tot += A[right]
            right += 1
#        print(ret, left, right)
        ret += right - left                  #####値の更新
        tot = tot ^ A[left]
    print(ret)

def __starting_point():
    main()
__starting_point()

#!/usr/bin/env python3

import sys

DEBUG = False

def read(t):
    return t(sys.stdin.readline().rstrip())


def read_list(t, sep = " "):
    return [t(s) for s in sys.stdin.readline().rstrip().split(sep)]


def dprint(*args, **kwargs):
    if DEBUG:
        print(*args, **kwargs)
    return

def main():
    n = read(int)
    a = read_list(int)

    ans = 0
    l = r = 0
    cur_sum = 0

    for l in range(0, n):
        if r < l:
            r = l
        while r < n and (cur_sum | a[r]) == cur_sum + a[r]:
            cur_sum += a[r]
            r += 1
        ans += r - l
        if l < r:
            cur_sum -= a[l]
    
    print(ans)


def __starting_point():
    main()

__starting_point()

import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = list(map(int, read().split()))

    s = 0
    ans = 0
    right = 0
    for left in range(N):
        while right < N and s & A[right] == 0:
            s ^= A[right]
            right += 1

        ans += right - left

        if left == right:
            right += 1
        else:
            s ^= A[left]

    print(ans)
    return


def __starting_point():
    main()

__starting_point()

N = int(input())
A = list(int(a) for a in input().split())

ans = 0
x_sum = 0
a_sum = 0
r = 0
for l in range(N):
    while r < N and x_sum^A[r] == a_sum+A[r]:
        x_sum ^= A[r]
        a_sum += A[r]
        r += 1
    ans += r-l
    #print(l, r, x_sum, a_sum, ans)
    x_sum ^= A[l]
    a_sum -= A[l]

print(ans)

# a + b <= a ^ b
# 部分列の和が排他的論理和よりも大きくなってらそれ以降の区間で和に追いつけなくなる
# 和と排他的論理和が等しい区間を尺取りで求める
n = int(input())
a = list(map(int, input().split()))

l = 0
SUM,XOR = 0,0
ans= 0
for r in range(n):
    SUM += a[r]
    XOR ^= a[r]
    if SUM == XOR:
        ans += (r-l+1)
    else:
        while l <= r and SUM != XOR:
            SUM -= a[l]
            XOR ^= a[l]
            l += 1
        ans += (r-l+1)

print(ans)

from operator import*
from copy import*
class TP:
    def __init__(self, cond, init=0, right=add, left=sub):
        self.cond = cond
        self.init = init
        self.next_right = right
        self.next_left = left
    
    def __call__(self, A, uniq=True):
        cond = self.cond
        next_right, next_left = self.next_right, self.next_left
        s = deepcopy(self.init)
        n = len(A)
        X = {}
        r = 0
        for l in range(n):
            if not uniq:
                X[l] = r
            while r < n and cond(s, A[r]):
                s = next_right(s, A[r])
                r += 1
                X[l] = r
            if l == r:
                r += 1
            else:
                s = next_left(s, A[l]) if l+1 != r else deepcopy(self.init)
        return list(X.items())
    
    def maximum(self, A):
        X = self.__call__(A)
        return max(r-l for l, r in X) if X else 0
    
    def count(self, A):
        X = self.__call__(A, False)
        return sum(r-l for l, r in X)
 
n, *a = map(int, open(0).read().split())
print(TP(lambda s, n: s + n == s ^ n).count(a))

n = int(input())
A = tuple(map(int, input().split()))
c = 0
s = 0
r = 0
for l in range(n):
    while r < n and A[r] ^ s == A[r] + s:
        s = A[r] + s
        r += 1

    c += r- l
    if l == r:
        r += 1
    else:
        s -= A[l]

print(c)


import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = list(map(int, read().split()))

    s = 0
    xors = 0
    ans = 0
    right = 0
    for left in range(N):
        while right < N and xors ^ A[right] == s + A[right]:
            xors ^= A[right]
            s += A[right]
            right += 1

        ans += right - left

        if left == right:
            right += 1
        else:
            xors ^= A[left]
            s -= A[left]

    print(ans)
    return


def __starting_point():
    main()

__starting_point()

n = int(input())
a = list(map(int,input().split()))
t = 0
l = 0
r = 0
ans = 0
while r < n:
    if t^a[r] == t+a[r]:
        t += a[r]
        r += 1
    else:
        t -= a[l]
        ans += r-l
        l += 1
ans += (r-l)*(r-l+1)//2
print(ans)

n=int(input())
a=list(map(int,input().split()))

l=0
r=1
t=a[0]
ans=0

while l<n:
  if r==n:
    ans+=r-l
    l+=1
    continue
  if t+a[r]==t^a[r]:
    t+=a[r]
    r+=1
  else:
    ans+=r-l
    t-=a[l]
    l+=1
print(ans)


#!/usr/bin/env python3
import sys
try:
    from typing import List
except ImportError:
    pass


def solve(N: int, A: "List[int]"):
    ans = 0
    j = 0
    x = 0
    for i in range(N):
        while j < N and (x & A[j]) == 0:
            x ^= A[j]
            j += 1
        ans += j - i
        x ^= A[i]
    print(ans)


def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    solve(N, A)


def __starting_point():
    main()

__starting_point()

import sys
input = sys.stdin.readline
N=int(input())
L=list(map(int,input().split()))
t=0
ans=0
l=0
r=0
while r<=N-1:
 if t+L[r]==t^L[r]:
  t+=L[r]
  r+=1
 else:
  ans+=(r-l)
  t-=L[l]
  l+=1
ans+=(r-l)*(r-l+1)/2
print(int(ans))

# Python3 (3.4.3)
import sys
input = sys.stdin.readline

# -------------------------------------------------------------
# function
# -------------------------------------------------------------


# -------------------------------------------------------------
# main
# -------------------------------------------------------------
N = int(input())
A = list(map(int,input().split()))

# xor と + の結果が等しいのは, 2進表記で各桁のbitが立っている数が1つしかない場合
# しゃく取りで求められそう
ans = 0
xor = 0 # しゃくとり の本体
l,r = 0,0

while r < N:
    # 右に要素を追加できるなら
    if xor ^ A[r] == xor + A[r]:
        ans += r-l+1
        xor ^= A[r]
    # 右の要素が追加できないなら
    else:
        # 条件を満たすまで左端を更新
        while xor ^ A[r] != xor + A[r]:
            xor ^= A[l]
            l += 1
        # 条件を満たしたので, 計算
        xor ^= A[r]
        ans += r-l+1
    r += 1

print(ans)


#!/usr/bin/env python3
import sys
from collections import deque, Counter
from heapq import heappop, heappush
from bisect import bisect_right
from itertools import accumulate

sys.setrecursionlimit(10**6)
INF = 10**12
m = 10**9 + 7

def main():
    N = int(input())
    A = list(map(int, input().split()))

    # しゃくとり法の練習
    res = 0
    right = 0
    sumA = 0# leftからrightまでの算術和（=論理和）

    for left in range(N):
        while right < N and (sumA+A[right]) == sumA^A[right]:
            sumA += A[right]
            right += 1

        res += right - left
        if left == right:
            right += 1
        else:
            sumA -= A[left]

    print(res)

def __starting_point():
    main()

__starting_point()

from sys import stdin
def main():
    #入力
    readline=stdin.readline
    n=int(readline())
    a=list(map(int,readline().split()))

    l=0
    r=1
    ans=0
    now_xor=a[0]
    now_sum=a[0]
    while l<n:
        if r<n:
            now_xor^=a[r]
            now_sum+=a[r]
            while now_xor!=now_sum:
                ans+=1
                ans+=r-l-1
                now_xor^=a[l]
                now_sum-=a[l]
                l+=1
            r+=1
        else:
            l+=1
            ans+=1
            ans+=r-l

    print(ans)

def __starting_point():
    main()
__starting_point()

import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = list(map(int, read().split()))
    A = [list(map(int, f'{a:0>20b}')) for a in A]

    ans = 0
    right = 0
    digits = [0] * 20

    for left in range(N):
        while right < N and all(d + b <= 1 for d, b in zip(digits, A[right])):
            for i in range(20):
                digits[i] += A[right][i]
            right += 1

        ans += right - left

        if left == right:
            right += 1
        else:
            for i in range(20):
                digits[i] -= A[left][i]

    print(ans)
    return


def __starting_point():
    main()

__starting_point()

from operator import add, sub
from operator import mul, floordiv
class Two_pointer:
    def __init__(self, cond, init=0, right=add, left=sub):
        self.cond = cond
        self.init = init
        self.next_right = right
        self.next_left = left
        
    def __call__(self, A):
        cond = self.cond
        next_right, next_left = self.next_right, self.next_left
        s = init = self.init
        n = len(A)
        X = {}
        r = 0
        for l in range(n):
            X[l] = r
            while r < n and cond(s, A[r]):
                s = next_right(s, A[r])
                r += 1
                X[l] = r
            if l == r:
                r += 1
            else:
                s = next_left(s, A[l]) if l+1 != r else init
        return list(X.items())

n, *A = map(int, open(0).read().split())
X = Two_pointer(lambda s, n: s + n == s ^ n)(A)
print(sum(r-l for l, r in X))

#!/usr/bin/env python3

n = int(input())
a = list(map(int, input().split()))

total = a[0]
xor = a[0]
ans = 0
l = 0
r = 0

while 1:
    if xor == total:
        ans += r-l+1
        r += 1
        if r == n:
            break
        total += a[r]
        xor ^= a[r]
    else:
        total -= a[l]
        xor ^= a[l]
        l += 1
print(ans)


def main():
    N = int(input())
    A = list(map(int, input().split()))
    l, t, n = 0, 0, 0
    for r, a in enumerate(A):
        while a & t:
            t ^= A[l]
            l += 1
        t |= a
        n += r - l + 1
    return n

print((main()))


def main():
    n = int(input())
    a = list(map(int, input().split()))

    if n == 1:
        print(1)
        return

    # Only when there is no bit duplication in a group,
    # it always meets the condition.
    # l <= true_l < true_r < r
    ans = n
    l = 0
    now = a[0]
    for r in range(1, n):
        if now & a[r] == 0:
            now = now ^ a[r]
            continue

        now = now ^ a[r]
        for new_l in range(r-1, l-1, -1):
            if a[new_l] & a[r] != 0:
                break
        # else:
            # print('Error')
            # return
        new_l += 1

        for i in range(l, new_l):
            now = now ^ a[i]

        ans += (r-l) * (r-l-1) // 2 - (r-new_l) * (r-new_l-1) // 2

        l = new_l

    r += 1
    ans += (r-l) * (r-l-1) // 2

    print(ans)

main()

n=int(input())
a=tuple(map(int,input().split(' ')))
r,ans,tsum,txor=0,0,0,0
for l in range(n):
    while r<n and txor^a[r]==tsum+a[r]:
        txor = txor^a[r]
        tsum = tsum+a[r]
        r += 1
    ans += r-l
    if l==r:
        r+=1
    else:
        txor = txor^a[l]
        tsum -= a[l]
print(ans)

N = int(input())
a_l = [int(a) for a in input().split()]

ans = 0
right = 0
_sum = 0
for left in range(N):
    while right < N and _sum ^ a_l[right] == _sum + a_l[right]:
        _sum += a_l[right]
        right += 1
    ans += right - left
    if right == left:
        right += 1
    else:
        _sum -= a_l[left]

print(ans)


#%%
N = int(input())
A = list(map(int, input().split()))

#%%
ans = 0
sum = 0
right = 0
for left in range(N):
    temp = 0
    while right < N and sum ^ A[right] == sum + A[right]:
        sum = sum ^ A[right]
        right += 1
    if left == right:
        right += 1
    else:
        sum = sum ^ A[left]
    ans += right - left
    
print(ans)


n = int(input())
a_ls = list(map(int, input().split()))
r = 0
ans = 0
S = a_ls[0]
for l in range(n):
    if l == r and S == 0:
        S = a_ls[l]
    while r + 1 < n and S+a_ls[r+1] == S^a_ls[r+1]:
        S += a_ls[r+1]
        r += 1
    ans += r - l + 1
    if r == l:
        r += 1
    S -= a_ls[l]
print(ans)



N = int(input())
A = list(map(int,input().split()))

right = 0
SUM = 0
ans = 0
for left in range(N):
    while right < N and SUM | A[right] == SUM + A[right]:
        SUM += A[right]
        right += 1
    
    ans += right - left
    
    if right == left:
        right += 1
    else:
        SUM -= A[left]
print(ans)

from operator import add, sub
from operator import mul, floordiv
class Two_pointer:
    def __init__(self, cond, init=0, right=add, left=sub):
        self.cond = cond
        self.s = init
        self.next_right = right
        self.next_left = left
        
    def __call__(self, A):
        s = self.s
        cond = self.cond
        next_right, next_left = self.next_right, self.next_left
        n = len(A)
        X = []
        r = 0
        for l in range(n):
            while r < n and cond(s, A[r]):
                s = next_right(s, A[r])
                X.append((l, r+1))
                r += 1
            if l == r:
                r += 1
            else:
                s = next_left(s, A[l])
        return X

n, *A = map(int, open(0).read().split())
X = Two_pointer(lambda s, n: s + n == s ^ n)(A)
print(sum(r-l for l, r in X))

import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = list(map(int, read().split()))

    csum = [[0] * 20 for _ in range(N + 1)]
    for i in range(N):
        for j in range(20):
            csum[i + 1][j] = csum[i][j] + (1 if A[i] & (1 << j) else 0)

    def is_ok(l, r):
        res = True
        for j in range(20):
            if csum[r][j] - csum[l][j] > 1:
                res = False
                break
        return res

    ans = 0
    right = 0
    for left in range(N):
        while right < N and is_ok(left, right + 1):
            right += 1

        ans += right - left

        if left == right:
            right += 1

    print(ans)
    return


def __starting_point():
    main()

__starting_point()

N = int(input())
A = list(map(int,input().split()))
A.append(0)

r = 0
ans = 0
su = 0

for l in range(N):
  while (l == r or su+A[r]==su^A[r]) and r<N:
    su += A[r]
    r+=1
  ans += r - l
  su -= A[l]
print(ans)

n = int(input())
a_list = [int(x) for x in input().split()]

ans = 0
temp_xor = a_list[0]
temp_sum = a_list[0]
r = 0
for l in range(n):
    while r < n:
        if temp_xor != temp_sum:
            break
        r += 1
        if r < n:
            temp_xor ^= a_list[r]
            temp_sum += a_list[r]
    ans += r - l
    temp_xor ^= a_list[l]
    temp_sum -= a_list[l]
print(ans)

import sys

sys.setrecursionlimit(10 ** 7)
input = sys.stdin.readline
f_inf = float('inf')
mod = 10 ** 9 + 7


def resolve():
    n = int(input())
    A = list(map(int, input().split()))

    res = 0
    left = 0
    add_total = 0
    xor_total = 0
    for right in range(n):
        add_total += A[right]
        xor_total ^= A[right]
        while add_total != xor_total:
            add_total -= A[left]
            xor_total ^= A[left]
            left += 1
        res += right - left + 1

    print(res)


def __starting_point():
    resolve()

__starting_point()

n = int(input())
A = list(map(int, input().split()))
ans = R = X = 0
for L in range(n):
    while R < n and not(X & A[R]):
        X ^= A[R]
        R += 1
    ans += R-L
    X ^= A[L]
print(ans)


N = int(input())
A = list(map(int,input().split()))
A.append(0)

right = 0
ans = 0
su = 0

for left in range(N):
    while (left == right or su + A[right] == su ^ A[right]) and right < N:
        su += A[right]
        right += 1
    ans += right - left
    su -= A[left]
print(ans)

import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = list(map(int, read().split()))

    ans = 0
    right = 0
    s = 0

    for left in range(N):
        while right < N and s & A[right] == 0:
            s ^= A[right]
            right += 1

        ans += right - left

        if left == right:
            right += 1
        else:
            s ^= A[left]

    print(ans)
    return


def __starting_point():
    main()

__starting_point()

n = int(input())
alst = list(map(int, input().split()))

total = alst[0]
xor = alst[0]
ans = 0
l = 0
r = 0
while 1:
    if xor == total:
        ans += r - l + 1
        r += 1
        if r == n:
            break
        total += alst[r]
        xor ^= alst[r]
    else:
        total -= alst[l]
        xor ^= alst[l]
        l += 1
print(ans)

N = int(input())
A = list(map(int, input().split()))+[0]

su = 0
ans = 0
right = 0

for left in range(N):
    while (left == right or su+A[right] == su^A[right]) and right < N:
        su += A[right]
        right += 1
    ans += right-left
    su -= A[left]
print(ans)

from heapq import heapify,heappush,heappop
n = int(input())
a = [int(i) for i in input().split()]

p = 0
ans = 0
cc = 0
cs = 0
chk = []
heapify(chk)
for i,ai in enumerate(a):
  heappush(chk,(i,ai))
  cc = cc^ai
  cs += ai
  ans += 1
  if cc != cs :
    p += (ans-1)*(ans)//2
    while chk:
      j,aj = heappop(chk)
      ans -= 1
      cc = cc^aj
      cs -= aj
      if cc == cs:
        p -= (ans-1)*(ans)//2
        cnt = 0
        break
p += ans*(ans+1)//2
print(p)

N = int(input())
A = list(map(int, input().split()))

xo = A[0]
l = 0
r = 1
ans = 0

while l < N:
    if r == N:
        ans += r - l
        l += 1
        continue
    if xo ^ A[r] == xo + A[r]:
        xo += A[r]
        r += 1
    else:
        ans += r - l
        xo ^= A[l]
        l += 1
print(ans)


import numpy as np

N = int(input())
A = list(map(int, input().split()))

# XOR和と加算和が等しくなるのは、二進数にしたときの各ビットの1の数が高々ひとつのとき
# → ある集合が条件を満たすとき、その部分集合も条件を満たす
# しゃくとり法
r = 0 # 右端の初期値
temp = 0
ans = 0 # 答えの初期値
for l in range(N): # 左端を動かしていく
    while r < N and temp ^ A[r] == temp + A[r]: # 右端を動かしても条件を満たすなら
        temp += A[r]
        r += 1
    # 条件を満たさなくなったら
    ans += r - l # 答えを更新
    # 左端を動かす準備
    if r == l:
        r += 1 # すでに重なっている場合は右端も動かす
        temp = 0
    else:
        temp -= A[l]
print(ans)

import sys
readline = sys.stdin.readline

N = int(readline())
A = list(map(int,readline().split()))

# 同じ桁に1が2回現れたらダメ
# 現在のビット列を持ち、同じ桁に1が2回現れない限り延長していく尺取り法

right = 0
xor = 0 # 現在のビット列
ans = 0

def isOk(x, v):
  while x and v:
    if (x & 1) and (v & 1):
      return False
    x >>= 1
    v >>= 1
  return True

for left in range(N):
  while right < N and isOk(xor,A[right]):
    # 同じ桁に1が2回現れないことをチェック
    xor ^= A[right]
    right += 1
      
  ans += (right - left)
  
  if right == left:
    right += 1
  else:
    xor ^= A[left]
  
print(ans)


n=int(input())
a=list(map(int,input().split()))

ll=0
rr=0
llrr=0

result=0

for ll in range(n):

    while rr<n and a[rr]&llrr==0:
        llrr+=a[rr]
        rr+=1
    result+=rr-ll
    llrr=llrr^a[ll]

print(result)





n = int(input())
aas = list(map(int, input().split()))
acc = 0
res = 0
r = 0
for i in range(n):
    ok = True
    while r < n:
        s = format(aas[r],'020b')
        acc_s = format(acc,'020b')
        for j in range(20):
            if s[j] == '1':
                if acc_s[j] == '1':
                    ok = False
                    #print(j)
        if ok:
            acc += aas[r]
            r += 1
        else:
            break
    if r < n:
        res += r - i
    else:
        res += r - i
    acc -= aas[i]
print(res)

def XorSum2():
    n = int(input())
    a = list(map(int, input().split()))
    ans, tmp0, tmp1 = 0, 0, 0
    
    # 尺取法インデックス
    right = 0

    for left in range(n):
        while right < n and tmp0^a[right] == tmp1+a[right]:
            tmp0 ^= a[right]
            tmp1 += a[right]
            right += 1
        ans += right-left
        if right == left:
            right += 1
            tmp0, tmp1 = 0, 0
        else:
            tmp0 ^= a[left]
            tmp1 -= a[left]
    print(ans)


def __starting_point():
    XorSum2()
    

__starting_point()

n = int(input())
a = list(map(int, input().split()))

result = 0
i = 0
x = 0
for j in range(n):
    while x < n and (i & a[x]) == 0:
        i += a[x]
        x += 1
    result += x-j
    i -= a[j]
print(result)

import sys
input = sys.stdin.readline


def main():
    N = int(input())
    A = [int(x) for x in input().split()]

    r = 0
    b = A[0]
    ans = 0
    for l in range(N):
        while r + 1 < N and A[r + 1] & b == 0:
            r += 1
            b |= A[r]
        ans += r - l + 1
        b = b ^ A[l]

    print(ans)




def __starting_point():
    main()


__starting_point()

N=int(input())
A=list(map(int,input().split()))
xsum,sum=A[0],A[0]
ans,x,y=0,0,0
flag=True
while flag:
  if xsum==sum:
    ans+=(x-y+1)
    x+=1
    if x==N:
      break
    sum+=A[x]
    xsum^=A[x]
  else:
    sum-=A[y]
    xsum^=A[y]
    y+=1
print(ans)

n,a=int(input()),list(map(int,input().split()));r,i,x=0,0,0
for j in range(n):
    while x<n and(i&a[x])==0:i+=a[x];x+=1
    r+=x-j;i-=a[j]
print(r)

n=int(input())
a=list(map(int,input().split()))
ans=0
k=0
Xor=0
Add=0
for i in range(n):
    while k<n and Xor^a[k]==Add+a[k]:
        Xor^=a[k]
        Add+=a[k]
        k+=1
    ans+=k-i
    Xor^=a[i]
    Add-=a[i]
print(ans)

N = int(input())
A = list(int(a) for a in input().split())

ans = 0
x_sum = 0
a_sum = 0
r = -1
for l in range(N):
    while x_sum == a_sum and r < N-1:
        r += 1
        x_sum ^= A[r]
        a_sum += A[r]
    if x_sum != a_sum:
        x_sum ^= A[r]
        a_sum -= A[r]
        r -= 1
    ans += r-l+1
    #print(l, r, x_sum, a_sum, ans)
    x_sum ^= A[l]
    a_sum -= A[l]

print(ans)

# coding: utf-8
import sys

sr = lambda: sys.stdin.readline().rstrip()
ir = lambda: int(sr())
lr = lambda: list(map(int, sr().split()))

# しゃくとり法
N = ir()
A = lr()
answer = 0
left = 0
right = 0

temp = A[left]
while left < N:
    while right < N-1:
        num = A[right+1]
        if temp ^ num != temp + num:
            break
        temp += num
        right += 1
    right = max(right, left)
    answer += right - left + 1
    temp -= A[left]
    left += 1

print(answer)


N = int(input())
A = [0] + list(map(int, input().split()))

ans = 0
S = 0
X = 0
end = 0

for i in range(1, N+1):
  S -= A[i-1]
  X ^= A[i-1]
  if end == N:
    ans += end - i + 1
    continue
  if end < N:
    end += 1
  for j in range(end, N+1):
    S += A[j]
    X ^= A[j]
    if S != X:
      S -= A[j]
      X ^= A[j]
      end = j-1
      break
    if j == N:
      end = j
  ans += end - i + 1

print(ans)

import sys
import numpy as np

sys.setrecursionlimit(10 ** 6)
INF = float("inf")
MOD = 10 ** 9 + 7


def input():
    return sys.stdin.readline().strip()


def main():
    N = int(input())
    A = list(map(int, input().split()))

    # a ^ b <= a + b が成り立つ
    ans = 0
    right = 0
    xor = 0
    s = 0
    for left in range(N):
        while right < N and s + A[right] == xor ^ A[right]:
            s += A[right]
            xor ^= A[right]
            right += 1

        ans += right - left

        if right == left:
            right += 1
        else:
            s -= A[left]
            xor ^= A[left]

    print(ans)


def __starting_point():
    main()

__starting_point()

n = int(input())
aaa = list(map(int, input().split()))
right = 0
sum = 0
cnt = 0
for left in range(n):
    while right < n and (sum ^ aaa[right]) == (sum + aaa[right]):
        sum += aaa[right]
        right += 1
    cnt += right - left
    if left == right:
        right += 1
    else:
        sum -= aaa[left]
print(cnt)

import sys
input = sys.stdin.readline


def main():
    N = int(input())
    A = [int(x) for x in input().split()]

    r = 0
    b = 0
    ans = 0
    for l in range(N):
        while r < N and A[r] & b == 0:
            b |= A[r]
            r += 1
        ans += r - l
        b = b ^ A[l]

    print(ans)




def __starting_point():
    main()


__starting_point()

import sys

read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
sys.setrecursionlimit(10 ** 9)
INF = 1 << 60
MOD = 1000000007


def main():
    N, *A = list(map(int, read().split()))

    ans = 0
    right = 0
    s = 0

    for left in range(N):
        while right < N and s & (s ^ A[right]) == s:
            s ^= A[right]
            right += 1

        ans += right - left

        if left == right:
            right += 1
        else:
            s ^= A[left]

    print(ans)
    return


def __starting_point():
    main()

__starting_point()

import sys


def input():
    return sys.stdin.readline().strip()


MOD = 10 ** 9 + 7
sys.setrecursionlimit(20000000)
INF = float("inf")


def main():
    N = int(input())
    A = list(map(int, input().split()))
    # 初期値
    right, ans, tmp = 0, 0, 0

    # leftは0〜Nまで
    for left in range(N):
        while right < N and tmp ^ A[right] == tmp + A[right]:
            tmp += A[right]
            ans += right - left + 1
            right += 1

        # リストの長さが0になったら、どちらも一つ進める
        if left == right:
            right += 1
        # それ以外の場合はleftを一つ進める(合計値から一番左の値を引いておく)
        else:
            tmp -= A[left]
    print(ans)


def __starting_point():
    main()

__starting_point()

N = int(input())
A = list(map(int, input().split()))
ans = r = x = 0

for l in range(N):
  while r < l or r < N and x ^ A[r] == x + A[r]:
    x^=A[r]
    r+=1
  ans+=r-l
  x^=A[l]

print(ans)

N = int(input())
A = list(map(int, input().split()))

rt = 0
res = 0
x = 0
s = 0

for lt in range(N):
    while rt < N and x ^ A[rt] == s + A[rt]:
        x ^= A[rt]
        s += A[rt]
        rt += 1
    res += rt - lt
    x ^= A[lt]
    s -= A[lt]

print(res)

#!/usr/bin/env python3
import sys

def solve(N: int, A: "List[int]"):
    ans, t, s = 0, 0, 0
    for h in range(N):
        while t < N and s ^ A[t] == s + A[t]:
            s += A[t]
            t += 1
        ans += t - h
        s -= A[h]
    return ans

# Generated by 1.1.6 https://github.com/kyuridenamida/atcoder-tools
def main():
    def iterate_tokens():
        for line in sys.stdin:
            for word in line.split():
                yield word
    tokens = iterate_tokens()
    N = int(next(tokens))  # type: int
    A = [int(next(tokens)) for _ in range(N)]  # type: "List[int]"
    print((solve(N, A)))

def test():
    import doctest
    doctest.testmod()

def __starting_point():
    #test()
    main()

__starting_point()

n = int(input())
A = list(map(int, input().split()))
xsum = A[0]
asum = A[0]
ans = 0
left, right = 0, 0

while True:
  if xsum == asum:
    ans += right - left + 1
    right += 1
    if right == n:
      break
    asum += A[right]
    xsum ^= A[right]
  else:
    asum -= A[left]
    xsum ^= A[left]
    left += 1
print(ans)


import sys
readline = sys.stdin.readline

N = int(readline())
A = list(map(int,readline().split()))

def isOk(xor, val):
  while xor and val:
    if xor & 1 and val & 1:
      return False
    xor >>= 1
    val >>= 1
  return True
  
xor = 0
right = 0
ans = 0
for left in range(N):
  while right < N and isOk(xor, A[right]):
    xor ^= A[right]
    right += 1
  ans += right - left
  
  if left == right:
    right += 1
  else:
    xor ^= A[left]
    
print(ans)

N = int(input())
A = list(map(int, input().split()))

r = 0
xor = 0
total = 0
cnt = 0
for l in range(N):
    while r < N and total + A[r] == xor ^ A[r]:
        total += A[r]
        xor ^= A[r]
        r += 1

    cnt += r - l
    
    total -= A[l]
    xor ^= A[l]
print(cnt)

def main():
    n = int(input())
    a = list(map(int, input().split()))
    right = 0
    now_sum = 0
    now_xor = 0
    ans = 0
    for left in range(n):
        while right < n and a[right] + now_sum == now_xor ^ a[right]:
            now_sum += a[right]
            now_xor ^= a[right]
            right += 1
        ans += right - left
        if right == left:
            right += 1
        else:
            now_sum -= a[left]
            now_xor ^= a[left]
    print(ans)


def __starting_point():
    main()

__starting_point()

N = int(input())
num = list(map(int, input().split()))

ans = 0
r = 0
sumz = 0
for l in range(N):
    if r < l: r = l

    while (r < N) and (num[r] + sumz) == (sumz ^ num[r]):
        sumz += num[r]
        r += 1

    ans += r-l
    sumz -= num[l]

print(ans)


def main():
    N = int(input())
    A = list(map(int, input().split(' ')))
    ng = 0
    cum_xor = 0
    # しゃくとり法でngケースをカウントしていく
    right = 0
    for left in range(N):
        if left > 0:
            # 1つ前由来の立っているbitを消す
            cum_xor ^= A[left - 1]
        # 同時に立っているbitが無い限りxorをとり続ける
        while right < N and cum_xor & A[right] == 0:
            cum_xor ^= A[right]
            right += 1
        # 左端がleftとなるngケースの数を加算
        ng += N - right
    print(N * (N + 1) // 2 - ng)


def __starting_point():
    main()
__starting_point()

N = int(input())
A = list(map(int, input().split()))

ans = 0
S = 0
X = 0
end = -1

for i in range(N):
  while end < N-1:
    end += 1
    S += A[end]
    X ^= A[end]
    if S != X:
      S -= A[end]
      X ^= A[end]
      end -= 1
      break
  ans += end - i + 1
  S -= A[i]
  X ^= A[i]

print(ans)

# coding: utf-8

# https://atcoder.jp/contests/abc098/tasks/arc098_b
# give up
# 15:29-16:15


def bin20(x):
    bin_x = bin(x)[2:]
    x_len = len(bin_x)

    return list(map(int, "0" * (20-x_len) + bin_x))


def main():
    N = int(input())
    A = list(map(int, input().split()))
    A = [bin20(a) for a in A]

    ans = 0
    left = 0
    right = 0
    sum20 = [0] * 20
    pre_right = -1
    while True:
        if right > pre_right:
            for k in range(20):
                sum20[k] += A[right][k]

        pre_right = right

        if 2 in sum20:
            for k in range(20):
                sum20[k] -= A[left][k]
            ans += right - left
            left += 1
        else:
            right += 1

        if right == N:
            ans += (N-left) * (N-left+1) // 2

            return ans


print((main()))


N = int(input())
A = [int(i) for i in input().split()]

left = 0
total = 0
xor = 0
ans = 0
for right in range(N):
    total += A[right]
    xor ^= A[right]
    while total != xor:
        total -= A[left]
        xor ^= A[left]
        left += 1
    ans += right - left + 1
    
print(ans)

def ind(S):
  L4=list()
  for i in range(len(S)):
    if S[len(S)-i-1]=="1":
      L4.append(i)
  return set(L4)
N=int(input())
L=list(map(int,input().split()))
L=[ind(bin(i)[2:]) for i in L]
ans=0
n=0
i=0
T=set()
while True:
  if i==N and n==N:
    break
  elif i==N:
    ans+=i-n
    n+=1
    continue
  if T&L[i]==set():
    T=T|L[i]
    ans+=1
    i+=1
  else:
    T=T-L[n]
    n+=1
    ans+=i-n
  if i==N and n!=N:
    n+=1
print(ans)

def abc098_d():
    n = int(input())
    A = list(map(int, input().split()))
    ans = 0
    rt = 0
    total = 0
    for lf in range(n):
        while rt < n:
            if total ^ A[rt] == total + A[rt]:
                total += A[rt]
                rt += 1
            else:
                break
        ans += rt - lf
        if lf == rt: rt += 1
        else: total -= A[lf]
    print(ans)

def __starting_point():
    abc098_d()
__starting_point()