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

#define rep(i, a, b) for(int i = a; i < (b); ++i)
#define trav(a, x) for(auto& a : x)
#define all(x) begin(x), end(x)
#define sz(x) (int)(x).size()
#define subnb true
#define Lnb true
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;

#define lson(x) 2*x+1
#define rson(x) 2*x+2

//const int N = (int)1e5 + 50;
const int N = (int)100 + 50;
const int INF = (int)1e9;

struct Tree {
    int dat[N * 4];
    void init(int n) {
        fill(dat, dat + 4 * n, -1);
    }
    void update(int pos, int x, int l, int r, int val) {
        if(l == r) {dat[x] = max(dat[x], val); return ;}
        int mid = (l + r) / 2;
        if(pos <= mid) update(pos, lson(x), l, mid, val);
        else update(pos, rson(x), mid + 1, r, val);
        dat[x] = max(dat[lson(x)], dat[rson(x)]);
    }
    int query(int a, int b, int x, int l, int r) {
        if(r < a || b < l) return -1;
        int mid = (l + r) / 2;
        if(a <= l && r <= b) return dat[x];
        return max(query(a, b, lson(x), l, mid), query(a, b, rson(x), mid + 1, r));
    }
} tree[30];

template<class T>
struct RMQ {
    vector<vector<T>> jmp;

    RMQ(const vector<T>& V) {
        int N = sz(V), on = 1, depth = 1;
        while (on < sz(V)) on *= 2, depth++;
        jmp.assign(depth, V);
        rep(i,0,depth-1) rep(j,0,N)
                jmp[i+1][j] = (jmp[i][j] | jmp[i][min(N - 1, j + (1 << i))]);
    }

    T query(int a, int b) {
        b++;
        if(a == b) return 0;
//        assert(a < b); // or return inf if a == b
        int dep = 31 - __builtin_clz(b - a);
        return jmp[dep][a] | jmp[dep][b - (1 << dep)];
    }
};


int n, q;
vi a;
struct Qr {
    int r, idx;
};
pii res[N];
vector<Qr> qrs[N];

int main() {
    ios::sync_with_stdio(false);
    cin.tie(NULL);

    int T;
    cin >> T;
    while(T--) {
        cin >> n >> q;
        a.resize(n);
        rep(i, 0, n) cin >> a[i];
        RMQ<int> rmq(a);

//        tree.init(0, 0, n - 1);
        rep(i, 0, 30) tree[i].init(n);
        rep(i, 0, n) qrs[i].clear();
        rep(i, 0, q) {
            int l, r;
            cin >> l >> r;
            l--, r--;
            qrs[l].push_back({r, i});
        }
        vi la(30, n);
        auto add_num = [&](int i) {
            int rb = 0;
            for (int lb = 0; lb < 30; lb = rb + 1) {
                rb = lb;
                while(rb < 30 && !(a[i] >> rb & 1)) rb++;
                if(rb >= 30) break;
                assert(a[i] >> rb & 1);
                tree[lb].update(i, 0, 0, n - 1, rb);
            }
        };
        vi in(n, 0);
        for (int i = n - 1; i >= 0; i--) {
            rep(b, 0, 30) {
                if(a[i] >> b & 1) {
                    if(la[b] != n) {
                        in[la[b]]--;
                        if(in[la[b]] == 0) add_num(la[b]);
                    }
                    la[b] = i;
                    in[i]++;
                }
            }

            for (auto &qr : qrs[i]) {

                int r = qr.r, idx = qr.idx;
//                node nd = tree.query(l, r, 0, 0, n - 1);
                int sum = rmq.query(i, r);
                int high = 0;
                rep(b, 0, 30) if (sum >> b & 1) high = b;
                int want = (1 << (high + 1)) - 1;
                if (sum == want) {
                    res[idx] = {want, 0};
                } else {
                    int lb = INF, rb = -1;
                    rep(j, 0, high + 1) {
                        if (!(sum >> j & 1)) lb = min(lb, j), rb = max(rb, j);
                    }
                    // want to cover [lb, rb];
                    bool found = false;
                    rep(b, 0, lb) {
                        found |= tree[b].query(i, r, 0, 0, n - 1) >= rb;
                    }

                    rep(b, 0, 30) {
                        int li = la[b];
                        if(li <= r) {
                            int osum = rmq.query(i, li - 1) | rmq.query(li + 1, r);
                            rep(k, 0, 30) {
                                if((1 << k) <= a[li]) found |= (osum | (a[li] ^ (a[li] - (1 << k)))) == want;
                            }
                        }
                    }
                    res[idx] = {want, found ? 1 : 2};
//                    cout << want << " ";
//                    if (found) cout << 1 << "\n";
//                    else cout << 2 << '\n';
                }
            }
        }
        rep(i, 0, q) cout << res[i].first << " " << res[i].second << "\n";
    }
}