#include <bits/stdc++.h>

using namespace std;
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()

const int INF = (1 << 30);
const int K = 30;

struct SegTree {
    vector<int> vals;
    int N;

    void reset(vector<int>& A) {
        N = A.size();
        vals.resize(4 * N);
        build(0, 0, N, A);
    }

    void build(int v, int left, int right, vector<int>& A) {
        if (left + 1 == right) {
            vals[v] = A[left];
            return;
        }
        int mid = (left + right) / 2;
        build(2 * v + 1, left, mid, A);
        build(2 * v + 2, mid, right, A);
        vals[v] = min(vals[2 * v + 1], vals[2 * v + 2]);
    }

    int get(int v, int left, int right, int x, int y) {
        if (y <= left || right <= x)
            return INF;
        if (x <= left && right <= y)
            return vals[v];
        int mid = (left + right) / 2;
        return min(get(2 * v + 1, left, mid, x, y), get(2 * v + 2, mid, right, x, y));
    }
};

SegTree trees[K + 1];
const int MAXN = 100100;
int pref_sums[K + 1][MAXN];

void solve() {
    int n, q;
    cin >> n >> q;
    vector<int> A(n);
    for (int j = 0; j < K; ++j)
        pref_sums[j][0] = 0;
    for (int i = 0; i < n; ++i) {
        cin >> A[i];
        for (int j = 0; j < K; ++j) {
            int b = (A[i] >> j) & 1;
            pref_sums[j][i + 1] = pref_sums[j][i] + b;
        }
    }
    vector<int> B(n);
    for (int j = 0; j <= K; ++j) {
        for (int i = 0; i < n; ++i) {
            B[i] = A[i] >= (1 << j) ? (A[i] & ((1 << j) - 1)) : INF;
        }
        trees[j].reset(B);
    }
    while (q--) {
        int ll, rr;
        cin >> ll >> rr;
        --ll;
        int have_or = 0;
        int mx_bit = -1;
        for (int j = 0; j < K; ++j) {
            int cnt = pref_sums[j][rr] - pref_sums[j][ll];
            if (cnt) {
                have_or += 1 << j;
                mx_bit = max(mx_bit, j);
            }
        }
        if (have_or == (1 << (mx_bit + 1)) - 1) {
            cout << have_or << ' ' << 0 << '\n';
            continue;
        }
        // check if can in one op
        vector<pair<int, int>> bad;
        int mn_zero = mx_bit;
        int mx_zero = -1;
        for (int j = 0; j <= mx_bit; ++j) {
            int cnt = pref_sums[j][rr] - pref_sums[j][ll];
            if (cnt == 1) {
                int id = lower_bound(pref_sums[j] + ll, pref_sums[j] + rr, pref_sums[j][ll] + 1) - pref_sums[j];
                bad.emplace_back(id - 1, j);
            }
            if (cnt == 0) {
                mn_zero = min(mn_zero, j);
                mx_zero = max(mx_zero, j);
            }
        }
        ++mx_zero;
        bool pos = false;

        sort(bad.begin(), bad.end());
        for (int i = 0; i < bad.size(); ++i) {
            if ((i == 0 || bad[i - 1].first != bad[i].first) && (i + 1 == bad.size() || bad[i + 1].first != bad[i].first)) {
                // unique bad
                if (bad[i].second >= mx_zero && (A[i] & ((1 << bad[i].second) - 1)) < (1 << mn_zero)) {
                    //cerr << bad[i].first << ' ' << bad[i].second << "here\n";
                    pos = true;
                }
            }
        }
        int pr = ll;
        for (int i = 0; i < bad.size(); ++i) {
            int cur = bad[i].first;
            if (pr < cur) {
                // check on subsegment
                if (trees[mx_zero].get(0, 0, n, pr, cur) < (1 << mn_zero)) {
                    //cerr << pr << ' ' << cur << " here segm\n";
                    pos = true;
                }
            }
            pr = cur + 1;
        }
        if (pr < rr) {
            if (trees[mx_zero].get(0, 0, n, pr, rr) < (1 << mn_zero)) {
                //cerr << pr << ' ' << rr << " here segm\n";
                pos = true;
            }
        }
        cout << ((1 << (mx_bit + 1)) - 1) << ' ' << (pos ? 1 : 2) << '\n';
    }

}

signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int t;
    cin >> t;
    while (t--) {
        solve();
    }
    return 0;
}