#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <cmath>
#include <bitset>
using namespace std;


#define N 300030
#define M 200020
#define mod 1000000007
#define LL long long
#define ls (i << 1)
#define rs (ls | 1)
#define md (ll + rr >> 1)
#define lson ll, md, ls
#define rson md + 1, rr, rs
#define ui unsigned int

const double Pi = acos(-1.0);  
  
struct complex {  
    double r, i;  
    complex(double r = 0, double i = 0):r(r), i(i) {}  
    complex operator + (const complex &ot) const {  
        return complex(r + ot.r, i + ot.i);  
    }  
    complex operator - (const complex &ot) const {  
        return complex(r - ot.r, i - ot.i);  
    }  
    complex operator * (const complex &ot) const {  
        return complex(r * ot.r - i * ot.i, r * ot.i + i * ot.r);  
    }  
}x1[N], x2[N];  
  
void change(complex *y, int len) {  
    for(int i = 1, j = len / 2; i < len - 1; ++i) {  
        if(i < j) swap(y[i], y[j]);  
        int k = len / 2;  
        while(j >= k) {  
            j -= k;  
            k >>= 1;  
        }  
        j += k;  
    }  
}  
  
void FFT(complex *y, int len, int on) {  
    change(y, len);  
    for(int h = 2; h <= len; h <<= 1) {  
        complex wn = complex(cos(on * 2 * Pi / h), sin(on * 2 * Pi / h));  
        for(int j = 0; j < len; j += h) {  
            complex w = complex(1, 0);  
            for(int k = j; k < j + h / 2; ++k) {  
                complex u = y[k];  
                complex t = y[k+h/2] * w;  
                y[k] = u + t;  
                y[k+h/2] = u - t;  
                w = w * wn;  
            }  
        }  
    }  
    if(on == -1) {  
        for(int i = 0; i < len; ++i)  
            y[i].r /= len;  
    }  
}  
int n, a[N];
vector<int> g[N];
LL ans[N];
int val[N], len;

int mx[N << 2];

void build(int ll, int rr, int i) {
    if(ll == rr) {
        mx[i] = a[ll];
        return;
    }
    build(lson); build(rson);
    mx[i] = max(mx[ls], mx[rs]);
}
int query(int l, int r, int ll, int rr, int i) {
    if(ll == l && rr == r) return mx[i];
    if(r <= md) return query(l, r, lson);
    if(l > md) return query(l, r, rson);
    return max(query(l, md, lson), query(md + 1, r, rson));
}

void calc(vector<int> &vt) {
    int l = vt.size();
    int len = 1;
    while(len <= l * 2) len *= 2;
    for(int i = 0; i < l; ++i) {
        x1[i] = complex(vt[i], 0);
        x2[i] = complex(vt[l - i - 1], 0);
    }
    for(int i = l; i < len; ++i) x1[i] = x2[i] = complex(0, 0);
    FFT(x1, len, 1);
    FFT(x2, len, 1);
    for(int i = 0; i < len; ++i) x1[i] = x1[i] * x2[i];
    FFT(x1, len, -1);
    for(int i = 0; i < l; ++i)
        ans[i+1] += x1[i + l].r + 0.5;
}

void solve(int l, int r) {
    if(l > r) return;
    if(l == r) {
        ans[1]++;
        return;
    }
    int t = query(l, r, 1, n, 1);
    int x = lower_bound(g[t].begin(), g[t].end(), l) - g[t].begin();
    int y = upper_bound(g[t].begin(), g[t].end(), r) - g[t].begin() - 1;

    vector<int> tmp;
    tmp.push_back(g[t][x] - l + 1);
    for(int i = x + 1; i <= y; ++i) {
        tmp.push_back(g[t][i] - g[t][i-1]);
    }
    tmp.push_back(r - g[t][y] + 1);
    calc(tmp);
    solve(l, g[t][x] - 1);
    for(int i = x + 1; i <= y; ++i) solve(g[t][i-1] + 1, g[t][i] - 1);
    solve(g[t][y] + 1, r);
}
    


int main() {
    int cas;
    scanf("%d", &cas);
    while(cas--) {
        scanf("%d", &n);
        for(int i = 1; i <= n; ++i) g[i].clear();
        for(int i = 1; i <= n; ++i) {
            scanf("%d", &a[i]);
            g[a[i]].push_back(i);
        }
        build(1, n, 1);
        for(int i = 1; i <= n; ++i) ans[i] = 0;

        solve(1, n);
        LL res = 0;
        for(int i = 1; i <= n; ++i) {
            res += ((LL)i) ^ ans[i];
        }
        cout << res << endl;
    }
    return 0;
}