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

#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#define MOD 1000000007
#define HASH_MOD1 998244353
#define HASH_MOD2 1000000009
#define HASH 31
#define ll long long
#define int long long

typedef __gnu_pbds::tree<int, __gnu_pbds::null_type, less<int>, __gnu_pbds::rb_tree_tag, __gnu_pbds::tree_order_statistics_node_update> ordered_set;

template <typename T>
istream& operator>> (istream& in, vector<T>& a)
{
    for (int i = 0; i < a.size(); ++i)
        in >> a[i];

    return in;
}

template <typename T>
ostream& operator<< (ostream& out, vector<T>& a)
{
    for (int i = 0; i < a.size(); ++i)
        out << a[i] << " ";

    out << "\n";

    return out;
}

template <typename T>
ostream& operator<< (ostream& out, set<T>& s)
{
    for (int x : s)
        out << x << " ";

    out << "\n";

    return out;
}

template <typename T>
ostream& operator<< (ostream& out, vector<pair<T, T>>& v)
{
    for (int i = 0; i < v.size(); ++i)
        out << v[i].first << " " << v[i].second << "\n";

    return out;
}

ll modinv(ll a)
{
    return a <= 1 ? a : MOD - (MOD / a) * modinv(MOD % a) % MOD; 
}

ll binpow(ll x, ll y)
{
    ll ans = 1;

    while (y > 0)
    {
        if (y % 2 == 1)
            ans *= x;

        x = x * x;
        y = y / 2;

        x %= MOD;
        ans %= MOD;
    }

    return ans;
}

void build(vector<int>& st, vector<int>& a, int i, int ss, int se)
{
    if (ss == se)
    {
        st[i] = a[ss];
        return;
    }

    int mid = (ss + se) / 2;

    build(st, a, 2 * i + 1, ss, mid);
    build(st, a, 2 * i + 2, mid + 1, se);

    st[i] = min(st[2 * i + 1], st[2 * i + 2]);
}

int getMin(vector<int>& st, int i, int ss, int se, int l, int r)
{
    if (l > se || r < ss)
        return 1000;

    if (l <= ss && se <= r)
        return st[i];

    int mid = (ss + se) / 2;

    return (min(getMin(st, 2 * i + 1, ss, mid, l, r), getMin(st, 2 * i + 2, mid + 1, se, l, r)));
}

void update(vector<int>& st, int i, int ss, int se, int pos)
{
    if (pos < ss || pos > se)
        return;

    if (ss == se)
    {
        st[i] = 1000;
        return;
    }

    int mid = (ss + se) / 2;

    update(st, 2 * i + 1, ss, mid, pos);
    update(st, 2 * i + 2, mid + 1, se, pos);

    st[i] = min(st[2 * i + 1], st[2 * i + 2]);
}

void solve()
{
    int n, q, i, j;
    cin >> n >> q;

    vector<int> a(n);
    cin >> a;

    vector<vector<int>> v(32, vector<int>(4 * n, 1000));
    vector<vector<int>> prefix(32, vector<int>(n + 1, 0));
    vector<vector<int>> special_bits(n);

    for (j = 0; j < 32; ++j)
    {   
        vector<int> b(n, 1000);

        for (i = 0; i < n; ++i)
        {
            for (int y = j; y >= 0; --y)
            {
                int mask = (1LL << y);

                if (a[i] & mask)
                {
                    b[i] = y;
                    break;
                }
            }
        }

        build(v[j], b, 0, 0, n - 1);
    }

    for (j = 0; j < 32; ++j)
    {
        int mask = (1LL << j);

        for (i = 1; i <= n; ++i)
            prefix[j][i] = prefix[j][i - 1] + ((a[i - 1] & mask) > 0);
    }

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

        int highest = -1;
        int lowest = -1;
        int first_set = -1;

        for (j = 31; j >= 0; --j)
        {
            if (prefix[j][r + 1] - prefix[j][l] > 0)
            {
                first_set = j;
                break;
            }
        }

        for (j = first_set - 1; j >= 0; --j)
        {
            if (prefix[j][r + 1] - prefix[j][l] == 0)
            {
                lowest = j;

                if (highest == -1)
                    highest = j;
            }
        }

        int ans = (1LL << (first_set + 1)) - 1;

        if (lowest == -1)
        {
            cout << ans << " 0\n";
            continue;
        }

        set<int> s1, s2;

        for (j = 0; j <= 31; ++j)
        {
            int next = lower_bound(prefix[j].begin() + l, prefix[j].end(), prefix[j][l] + 2) - prefix[j].begin();
            --next;

            if (next > r && (prefix[j][r + 1] - prefix[j][l] > 0))
            {
                next = lower_bound(prefix[j].begin() + l, prefix[j].begin() + r + 2, prefix[j][l] + 1) - prefix[j].begin();
                --next;

                if (s1.count(next) == 0 && s2.count(next) == 0)
                    s1.insert(next);

                else
                {
                    s1.erase(next);
                    s2.insert(next);
                }

                special_bits[next].push_back(j);
            }
        }

        for (int ind : s1)
        {
            for (int b : special_bits[ind])
                update(v[b], 0, 0, n - 1, ind);
        }
        
        for (int ind : s2)
        {
            for (int b : special_bits[ind])
                update(v[b], 0, 0, n - 1, ind);
        }

        int mn_bit = getMin(v[highest], 0, 0, n - 1, l, r);

        if (mn_bit < l)
        {
            cout << ans << " 1\n";
            continue;
        }

        bool found = false;

        for (int ind : s1)
        {
            int num = a[ind];
            bool flag = true;

            for (j = lowest; j <= highest; ++j)
            {
                int mask = (1LL << j);

                if (num & mask)
                {
                    flag = false;
                    break;
                }
            }

            if (flag)
            {
                for (j = highest + 1; j <= 31; ++j)
                {
                    int mask = (1LL << j);

                    if ((num & mask) && special_bits[ind][0] == j)
                    {
                        found = true;
                        break;
                    }
                }

                if (found)
                {
                    cout << ans << " 1\n";
                    break;
                }
            }
        }

        if (!found)
            cout << ans << " 2\n";
    }
}

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

    int t = 1;
    cin >> t;

    while (t--)
    {
        solve();
    }
}