No Effect XOR

#include <bits/stdc++.h>
using namespace std;

using ll = long long;

void setIO() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
}

struct Basis {
    static const int B = 61;
    unsigned long long a[B]{};

    bool add(unsigned long long x) {
        for (int i = B - 1; i >= 0; --i) {
            if (!((x >> i) & 1ULL)) continue;
            if (!a[i]) {
                a[i] = x;
                return true;
            }
            x ^= a[i];
        }
        return false;
    }

    vector<unsigned long long> vecs() const {
        vector<unsigned long long> v;
        for (int i = 0; i < B; ++i) if (a[i]) v.push_back(a[i]);
        return v;
    }

    int rank() const {
        int res = 0;
        for (int i = 0; i < B; ++i) res += (a[i] != 0);
        return res;
    }
};

struct Space {
    bool empty = true;
    unsigned long long base = 0;
    Basis basis;
};

Space none() { return Space{}; }

Space point(unsigned long long x) {
    Space s;
    s.empty = false;
    s.base = x;
    return s;
}

Space full_space(int k) {
    Space s = point(0);
    for (int i = 0; i < k; ++i) s.basis.add(1ULL << i);
    return s;
}

Space normalize(Space s) {
    if (s.empty) return s;
    for (int i = Basis::B - 1; i >= 0; --i) {
        if (((s.base >> i) & 1ULL) && s.basis.a[i]) s.base ^= s.basis.a[i];
    }
    return s;
}

Space intersect_space(const Space& A, const Space& B) {
    if (A.empty || B.empty) return none();

    vector<unsigned long long> u = A.basis.vecs();
    vector<unsigned long long> v = B.basis.vecs();
    int n = (int)u.size(), m = (int)v.size();

    struct Row {
        unsigned long long val = 0, mask = 0;
    } row[61];

    auto add = [&](unsigned long long val, unsigned long long mask) -> unsigned long long {
        for (int bit = 60; bit >= 0; --bit) {
            if (!((val >> bit) & 1ULL)) continue;
            if (!row[bit].val) {
                row[bit] = {val, mask};
                return ULLONG_MAX;
            }
            val ^= row[bit].val;
            mask ^= row[bit].mask;
        }
        return mask;
    };

    for (int i = 0; i < n; ++i) add(u[i], 1ULL << i);
    for (int j = 0; j < m; ++j) add(v[j], 1ULL << (n + j));

    unsigned long long need = A.base ^ B.base;
    unsigned long long take = 0;
    for (int bit = 60; bit >= 0; --bit) {
        if (!((need >> bit) & 1ULL)) continue;
        if (!row[bit].val) return none();
        need ^= row[bit].val;
        take ^= row[bit].mask;
    }

    unsigned long long base = A.base;
    for (int i = 0; i < n; ++i) {
        if ((take >> i) & 1ULL) base ^= u[i];
    }

    Space res = point(base);

    Row depRow[61];
    auto dep_add = [&](unsigned long long val, unsigned long long mask) -> unsigned long long {
        for (int bit = 60; bit >= 0; --bit) {
            if (!((val >> bit) & 1ULL)) continue;
            if (!depRow[bit].val) {
                depRow[bit] = {val, mask};
                return ULLONG_MAX;
            }
            val ^= depRow[bit].val;
            mask ^= depRow[bit].mask;
        }
        return mask;
    };

    for (int i = 0; i < n; ++i) dep_add(u[i], 1ULL << i);
    for (int j = 0; j < m; ++j) {
        unsigned long long dep = dep_add(v[j], 1ULL << (n + j));
        if (dep == ULLONG_MAX) continue;

        unsigned long long dir = 0;
        for (int i = 0; i < n; ++i) {
            if ((dep >> i) & 1ULL) dir ^= u[i];
        }
        if (dir) res.basis.add(dir);
    }

    return normalize(res);
}

Space unite_affine(const Space& A, const Space& B) {
    if (A.empty) return B;
    if (B.empty) return A;

    Space res = A;
    res.basis.add(A.base ^ B.base);
    for (auto x : B.basis.vecs()) res.basis.add(x);
    return normalize(res);
}

pair<ll, ll> part(ll l, ll r, int k, int side) {
    if (l > r) return {1, 0};

    ll h = 1LL << (k - 1);
    ll L = side ? h : 0;
    ll R = side ? 2 * h - 1 : h - 1;

    l = max(l, L);
    r = min(r, R);
    if (l > r) return {1, 0};

    if (side) l -= h, r -= h;
    return {l, r};
}

struct Key {
    int k;
    ll a, b, c, d;

    bool operator==(const Key& o) const {
        return k == o.k && a == o.a && b == o.b && c == o.c && d == o.d;
    }
};

struct HashKey {
    size_t operator()(const Key& x) const {
        unsigned long long h = x.k;
        h = h * 1000003ULL + x.a;
        h = h * 1000003ULL + x.b;
        h = h * 1000003ULL + x.c;
        h = h * 1000003ULL + x.d;
        return h ^ (h >> 32);
    }
};

unordered_map<Key, Space, HashKey> memo;

Space trans(int k, ll l1, ll r1, ll l2, ll r2) {
    bool e1 = l1 > r1;
    bool e2 = l2 > r2;

    if (e1 || e2) {
        if (e1 && e2) return full_space(k);
        return none();
    }
    if (k == 0) return point(0);

    Key key{k, l1, r1, l2, r2};
    if (auto it = memo.find(key); it != memo.end()) return it->second;

    auto a0 = part(l1, r1, k, 0);
    auto a1 = part(l1, r1, k, 1);
    auto b0 = part(l2, r2, k, 0);
    auto b1 = part(l2, r2, k, 1);

    Space keep = intersect_space(
        trans(k - 1, a0.first, a0.second, b0.first, b0.second),
        trans(k - 1, a1.first, a1.second, b1.first, b1.second)
    );

    Space flip = intersect_space(
        trans(k - 1, a0.first, a0.second, b1.first, b1.second),
        trans(k - 1, a1.first, a1.second, b0.first, b0.second)
    );
    if (!flip.empty) flip.base ^= 1ULL << (k - 1);

    return memo[key] = unite_affine(keep, flip);
}

int main() {
    setIO();

    int t;
    cin >> t;
    while (t--) {
        ll l, r;
        cin >> l >> r;

        int k = 0;
        while ((1LL << k) <= r) ++k;

        memo.clear();
        Space ans = trans(k, l, r, l, r);
        cout << ((1LL << ans.basis.rank()) - 1) << '\n';
    }
}