class Solution {
public:
    int busyStudent(vector<int>& startTime, vector<int>& endTime, int queryTime) {
        int ret[1010] = {0};
        for(int i = 0;i < startTime.size();i++){
            ret[startTime[i]]++;
            ret[endTime[i] + 1]--;
        }
        for(int i = 1;i < 1010;i++){
            ret[i] += ret[i - 1];
        }
        return ret[queryTime];
    }
};

class Solution {
public:
    int hash[100010] = {0};
    int ret = 1;

    int maxEqualFreq(vector<int>& nums) {
        map<int,int>m; // 前一个是频率，后一个是次数
        set<int> s;
        for(int j = 0;j < nums.size();j++)
            s.insert(nums[j]);
        if (s.size() == 1)  return nums.size();
        else if(s.size() == nums.size())    return nums.size();
        int i = 0;
        for(i = 0;i < nums.size();i++){
            int x = ++hash[nums[i]];
            if(m.count(x - 1)){
                if(m[x - 1] == 1)   m.erase(x - 1);
                else    m[x - 1] --;
            }
            m[x] ++;
            auto pv = -- m.end();
            if(m.size() == 2 && ((m.begin()->first == 1 && m.begin()->second == 1) || (pv->first == m.begin()->first + 1 && pv->second == 1)))   ret = i;
        }
        return ret + 1;
    }
};

class Solution {
public:
    vector<int> f;

    void dfs(TreeNode* T,int depth){
        if(!T)  return;
        if(!T->left && !T->right){
            f[depth] += T->val;
            return;
        }
        if(T->left) dfs(T->left,depth + 1);
        if(T->right)    dfs(T->right,depth + 1);
    }

    int deepestLeavesSum(TreeNode* root) {
        this->f = vector<int>(10010,0);
        dfs(root,1);
        for(int i = f.size() - 1;i >= 0;i--)
            if(f[i])    return f[i];
        return 0;
    }
};

class OrderedStream {
private:
        int ptr;
        vector<string> s;
public:
    OrderedStream(int n) {
        ptr = 1;
        s.resize(n + 1);
    }

    vector<string> insert(int idKey, string value) {
        s[idKey] = value;
        vector<string> ret;
        if(idKey == ptr){
            while(ptr < s.size() && s[ptr] != ""){
                ret.push_back(s[ptr]);
                this->ptr ++;
            }
        }
        return ret;
    }
};

class MyCircularDeque {
private:
    vector<int> a;
    int capacity;
    int front,rear;
    int size;

public:
    MyCircularDeque(int k) {
        capacity = k + 1;
        front = 0;
        rear = 0;
        size = 0;
        a = vector<int>(k + 1);
    }

    bool insertFront(int value) {
        if(!isFull()){
            if(front != rear)   front = (front - 1 + capacity) % capacity;
            a[front] = value;
            if(rear == front)   rear++;
            size++;
            return true;
        }
        return false;
    }

    bool insertLast(int value) {
        if(!isFull()){
            a[rear] = value;
            rear = (rear + 1) % capacity;
            size ++;
            return true;
        }
        return false;
    }

    bool deleteFront() {
        if(size > 0){
            front = (front + 1) % capacity;
            size--;
            return true;
        }
        return false;
    }

    bool deleteLast() {
        if(size > 0){
            rear = (rear - 1 + capacity) % capacity;
            size--;
            return true;
        }
        return false;

    }

    int getFront() {
        if(!isEmpty())
            return a[front];
        return -1;
    }

    int getRear() {
        if(!isEmpty())
            return a[(rear - 1 + capacity) % capacity];
        return -1;
    }

    bool isEmpty() {
        return size == 0;
    }

    bool isFull() {
        return size == capacity - 1;
    }
};

#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>

using namespace std;
const int N = 300010;
int ret;
int a[N];

int main(){
    int n;
    cin >> n;
    unordered_map<int,int> hash[2];
    int sum = 0;
    hash[0][0]++;
    long long res = 0;
    for(int i = 1; i <= n;i++){
        cin >> a[i];
        sum ^= a[i];
        res += hash[i & 1][sum];
        hash[i & 1][sum]++;
    }

    cout << res << endl;
    return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

typedef long long LL;

const int N = 300010, Base = 111;
const LL Zero = 1e9;

int n, a, b;

int main()
{
    scanf("%d%d%d", &n, &a, &b);
    unordered_map<LL, int> hash1, hash2;

    while (n -- )
    {
        int vx, vy;
        scanf("%*d%d%d", &vx, &vy);
        hash1[vy - (LL)a * vx] ++ ;
        hash2[(vx + Zero) * Base + vy + Zero] ++ ;
    }

    LL res = 0;
    for (auto& [k, v]: hash1) res += v * (v - 1ll);
    for (auto& [k, v]: hash2) res -= v * (v - 1ll);

    printf("%lld\n", res);
    return 0;
}

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;

const int N = 510;
int f[N][N];
int n,m,k;

int main(){
    cin >> n >> m >> k;
    for(int i = 1;i <= n;i++)
        for(int j = 1;j <= m;j++){
            int x;
            cin >> x;
            f[i][j] = f[i - 1][j] + f[i][j - 1] - f[i - 1][j - 1] + x;
            //cout << f[i][j] << endl;
        }

    long res = 0;
    for(int i = 1;i <= n;i++){
        for(int j = i;j <= n;j++){
            for(int l = 1,r = 1;r <= m;r++){
                while(l <= r && f[j][r] - f[i - 1][r] - f[j][l - 1] + f[i - 1][l - 1] > k)  l++;
                if(l <= r)  res += r - l + 1;
            }
        }
    }
    cout << res << endl;
    return 0;
}

class Solution {
public:
    int maxChunksToSorted(vector<int>& arr) {
        stack<int> st;
        st.push(arr[0]);
        for(int i = 1;i < arr.size();i++){
            if(arr[i] >= st.top()){
               st.push(arr[i]);
            }
            else{
                int mx = st.top();
                st.pop();
                while(!st.empty() && arr[i] < st.top()){
                    st.pop();
                }
                st.push(mx);
            }
        }
        return st.size();
    }
};

class Solution {
public:
    vector<vector<int>> groupThePeople(vector<int>& groupSizes) {
        multimap<int,int>m;
        for(int i = 0;i < groupSizes.size();i++)
            m.emplace(groupSizes[i],i);
        vector<vector<int>> ret;
        vector<int>tmp;
        auto pv = m.begin();
        while(pv != m.end()){
            tmp.clear();   
            auto temp = pv;
            for(int i = 0;i < temp->first;i++){
                tmp.push_back(pv->second);
                pv++;
            }
            ret.push_back(tmp);
        }
        return ret;
    }
};