#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, int x)
{
    if (pos < ss || pos > se)
        return;

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

    int mid = (ss + se) / 2;

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

    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);
    vector<vector<int>> bits(32, vector<int>(n, -1));

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

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

        build(v[j], bits[j], 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)
        {
            if (prefix[j][r + 1] - prefix[j][l] == 1)
            {
                int next = lower_bound(prefix[j].begin() + l + 1, prefix[j].end(), prefix[j][l] + 1) - prefix[j].begin();
                
                --next;
                s1.insert(next);

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

        for (int ind : s1)
        {
            if (special_bits[ind].size() > 1)
                s2.insert(ind);
        }

        for (int ind : s2)
            s1.erase(ind);

        for (int ind : s1)
            update(v[highest], 0, 0, n - 1, ind, 1000);
        
        for (int ind : s2)
            update(v[highest], 0, 0, n - 1, ind, 1000);

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

        if (mn_bit < lowest)
        {
            cout << ans << " 1\n";
            found = true;
        }

        if (!found)
        {
            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;
                        }

                        else if (num & mask)
                            break;
                    }

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

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

        for (int ind : s1)
        {
            update(v[highest], 0, 0, n - 1, ind, bits[highest][ind]);
            special_bits[ind].clear();
        }

        for (int ind : s2)
        {
            update(v[highest], 0, 0, n - 1, ind, bits[highest][ind]);
            special_bits[ind].clear();
        }
    }
}

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

    int t = 1;
    cin >> t;

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