XOR and Favorite Number

Bob has a favorite number k and ai of length n. Now he asks you to answer m queries. Each query is given by a pair li and ri and asks you to count the number of pairs of integers i and j, such that l ≤ i ≤ j ≤ r and the xor of the numbers ai, ai + 1, …, aj is equal to k.

Input

The first line of the input contains integers n, m and k (1 ≤ n, m ≤ 100 000, 0 ≤ k ≤ 1 000 000) — the length of the array, the number of queries and Bob’s favorite number respectively.

The second line contains n integers ai (0 ≤ ai ≤ 1 000 000) — Bob’s array.

Then m lines follow. The i-th line contains integers li and ri (1 ≤ li ≤ ri ≤ n) — the parameters of the i-th query.

Output

Print m lines, answer the queries in the order they appear in the input.

Sample test(s)

Input

6 2 3
1 2 1 1 0 3
1 6
3 5

Output

7
0

Input

5 3 1
1 1 1 1 1
1 5
2 4
1 3

Output

9
4
4

Note

In the first sample the suitable pairs of i and j for the first query are: (1, 2), (1, 4), (1, 5), (2, 3), (3, 6), (5, 6), (6, 6). Not a single of these pairs is suitable for the second query.

In the second sample xor equals 1 for all subarrays of an odd length.

題意：有n個數和m次詢問，每一詢問會有一個L和R，表示所詢問的區間，問在這個區間中有多少個連續的子區間的亦或和為k

思路：本題只有詢問沒有修改，所以比較適合離線處理，而莫隊演算法是離線處理一類區間不修改查詢類問題的演算法。就是如果你知道了[L,R]的答案。你可以在O(1)的時間下得到[L,R-1]和[L,R+1]和[L-1,R]和[L+1,R]的答案的話。就可以使用莫隊演算法。，第一次接觸莫隊演算法感覺是一種很優雅的暴力，莫隊演算法是莫濤發明的。先對序列分塊。然後對於所有詢問按照L所在塊的大小排序。如果一樣再按照R排序。然後按照排序後的順序計算。為什麼這樣計算就可以降低複雜度呢。
一、i與i+1在同一塊內，r單調遞增，所以r是O(n)的。由於有n^0.5塊,所以這一部分時間複雜度是n^1.5。
二、i與i+1跨越一塊，r最多變化n，由於有n^0.5塊，所以這一部分時間複雜度是n^1.5
三、i與i+1在同一塊內時變化不超過n^0.5，跨越一塊也不會超過2*n^0.5，不妨看作是n^0.5。由於有n個數，所以時間複雜度是n^1.5於是就變成了O(n^1.5)了。
對於這道題，假設我們現在有一個字首異或和陣列sum[]，現在我們要求區間[L,R]的異或的值，用sum陣列表示就是sum[L-1]^sum[R]==K,或者說是K^sum[R]==sum[L-1]

詳細見程式碼

#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <vector>
#include <iostream>
#include <algorithm>
#define LL long long

using namespace std;

const int Max = 1100000;

const int MAXM = 1<<22;

typedef struct node
{
    int L ,R;

    int Id;
}Point ;

Point a[Max];

LL sum[Max];

LL ans[Max];

int n,m;

LL k;

int L,R;

LL cnt[MAXM],ant;

bool cmp(Point b,Point c)//將區間分塊排序
{
    if(b.L/400==c.L/400)
    {
        return b.R<c.R;
    }
    else
    {
        return b.L<c.L;
    }
}


void Dec(LL s) //將多算的數目去除
{
    --cnt[s];

    ant-=cnt[s^k];
}

void Inc(LL s)//將沒有遍歷的點對應的數目加上
{
    ant += cnt[s^k];

    cnt[s]++;
}

int main()
{
    scanf("%d %d %lld",&n,&m,&k);

    LL data;

    for(int i=1;i<=n;i++) //
    {
        scanf("%lld",&sum[i]);

        sum[i]^=sum[i-1];

    }

    for(int i=1;i<=m;i++)
    {
        scanf("%d %d",&a[i].L,&a[i].R);
        a[i].Id = i;
        a[i].L--;// 在這裡提前處理
    }
    sort(a+1,a+m+1,cmp);

    L=0,R=0,cnt[0]=1,ant=0;

    for(int i=1;i<=m;i++)
    {
        while(R<a[i].R)
        {
            Inc(sum[++R]);
        }

        while(R>a[i].R)
        {
            Dec(sum[R--]);
        }
        while(L<a[i].L)
        {
            Dec(sum[L++]);
        }
        while(L>a[i].L)
        {
            Inc(sum[--L]);
        }

        ans[a[i].Id]=ant;
    }
    for(int i=1;i<=m;i++)
    {
        printf("%lld\n",ans[i]);
    }
    return 0;
}