#include <bits/stdc++.h>

using i64 = long long;

constexpr int N = 1 << 18;

int mx[30][N];

void build(int d, int p, int l, int r, const std::vector<int> &v) {
    if (r - l == 1) {
        mx[d][p] = v[l];
        return;
    }
    int m = (l + r) / 2;
    build(d, 2 * p, l, m, v);
    build(d, 2 * p + 1, m, r, v);
    mx[d][p] = std::max(mx[d][2 * p], mx[d][2 * p + 1]);
}

int query(int d, int p, int l, int r, int x, int y) {
    if (l >= y || r <= x) {
        return -1;
    }
    if (l >= x && r <= y) {
        return mx[d][p];
    }
    int m = (l + r) / 2;
    return std::max(query(d, 2 * p, l, m, x, y), query(d, 2 * p + 1, m, r, x, y));
}

void solve() {
    int N, Q;
    std::cin >> N >> Q;
    
    std::vector<int> A(N);
    for (int i = 0; i < N; i++) {
        std::cin >> A[i];
    }
    
    std::vector nxt(N + 1, std::vector<int>(30, N));
    for (int i = N - 1; i >= 0; i--) {
        nxt[i] = nxt[i + 1];
        for (int j = 0; j < 30; j++) {
            if (A[i] >> j & 1) {
                nxt[i][j] = i;
            }
        }
    }
    
    std::vector lst(N + 1, std::vector<int>(30, 0));
    for (int i = 0; i < N; i++) {
        lst[i + 1] = lst[i];
        for (int j = 0; j < 30; j++) {
            if (A[i] >> j & 1) {
                lst[i + 1][j] = i + 1;
            }
        }
    }
    std::vector<int> val(N, -1);
    for (int j = 29; j >= 0; j--) {
        for (int i = 0; i < N; i++) {
            if (A[i] >> j & 1) {
                val[i] = j;
            }
        }
        build(j, 1, 0, N, val);
    }
    
    for (int i = 0; i < Q; i++) {
        int L, R;
        std::cin >> L >> R;
        L--;
        
        int t = 29;
        while (t >= 0 && nxt[L][t] >= R) {
            t--;
        }
        int ans = (1 << (t + 1)) - 1;
        
        bool zero = true;
        for (int j = 0; j <= t; j++) {
            if (nxt[L][j] >= R) {
                zero = false;
            }
        }
        int step = 2;
        if (zero) {
            step = 0;
        } else {
            std::vector<std::array<int, 3>> u;
            int pre = 0, suf = 0;
            int t = L;
            for (int j = 0; j < 30; j++) {
                if (nxt[L][j] < R) {
                    u.push_back({nxt[L][j], j, 0});
                }
            }
            for (int j = 0; j < 30; j++) {
                if (lst[R][j] > L) {
                    u.push_back({lst[R][j], j, 1});
                    suf |= 1 << j;
                }
            }
            std::sort(u.begin(), u.end());
            auto work = [&](int l, int r) {
                if (l == r) {
                    return;
                }
                int v = (pre | suf) ^ ans;
                assert(v > 0);
                int x = __builtin_ctz(v);
                int y = std::__lg(v);
                if (query(x, 1, 0, N, l, r) >= y) {
                    step = 1;
                }
            };
            for (auto [i, j, type] : u) {
                work(t, i);
                t = i;
                if (type == 0) {
                    pre ^= 1 << j;
                } else {
                    suf ^= 1 << j;
                }
            }
            work(t, R);
        }
        
        std::cout << ans << " " << step << "\n";
    }
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int t;
    std::cin >> t;
    
    while (t--) {
        solve();
    }
    
    return 0;
}