#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cassert>
#include <iostream>
#include <algorithm>
using namespace std;
 
const int MOD = 1000000007;
 
const int maxn = 1000;
int n;
long long f[maxn][maxn], a[maxn][maxn];
 
long long dfs(int x, int y)
{
    long long &ret = f[x][y];
    if (ret != -1) {
        return ret;
    }
    if (a[x][y] == 0) {
        return ret = 1;
    }
    ret = 0;
    if (x > 0 && a[x][y] == a[x - 1][y] + 1) {
        ret += dfs(x - 1, y);
    }
    if (y > 0 && a[x][y] == a[x][y - 1] + 1) {
        ret += dfs(x, y - 1);
    }
    if (x + 1 < n && a[x][y] == a[x + 1][y] + 1) {
        ret += dfs(x + 1, y);
    }
    if (y + 1 < n && a[x][y] == a[x][y + 1] + 1) {
        ret += dfs(x, y + 1);
    }
    return ret;
}
 
bool valid(long long l, long long r, long long length)
{
    // length = 2^{k+1}
    if (r - l - length / 2 >= (r - length / 2) % length) {
        return true;
    }
    if (r - l - length / 2 >= (r + 1) % length) {
        return true;
    }
 
    return false;
}
 
int main()
{
    int tests, test = 1;
    for (assert(scanf("%d", &tests) == 1 && 1 <= tests && tests <= 20000); test <= tests; ++ test) {
        long long l, r;
        assert(scanf("%lld%lld", &l, &r) == 2 && 1 <= l && l <= r && r <= 1000000000000000000LL);
 
        /*n = r - l + 1;
        for (long long x = l; x <= r; ++ x) {
            for (long long y = l; y <= r; ++ y) {
                a[x - l][y - l] = x ^ y;
            }
        }
        long long maxi = -1, cnt = 0;
        memset(f, -1, sizeof(f));
        for (int i = 0; i < n; ++ i) {
            for (int j = 0; j < n; ++ j) {
                if (f[i][j] == -1) {
                    if (dfs(i, j) > 0) {
                        if (a[i][j] > maxi) {
                            maxi = a[i][j];
                            cnt = f[i][j];
                        } else if (a[i][j] == maxi) {
                            cnt += f[i][j];
                        }
                    }
                }
            }
        }
 
        cout << maxi << " " << cnt << endl;*/
 
        long long maxi = 1;
        while (valid(l, r, maxi * 2)) {
            maxi *= 2;
        }
        if (maxi == 1) {
            cout << 0 << " " << (r - l + 1) % MOD << endl;
        } else {
            long long cnt = max(((maxi - 1) ^ l) - l + 1, 0LL) + max(r - ((maxi - 1) ^ r) + 1, 0LL);
            if ((l & (maxi - 1)) == 0) {
                cnt += maxi;
            }
            if ((r & (maxi - 1)) == maxi - 1) {
                cnt += maxi;
            }
            if (((maxi - 1) ^ r) < ((maxi - 1) ^ l)) {
                cnt -= maxi * 2;
            }
            cnt %= MOD;
            cout << maxi - 1 << " " << cnt * ((maxi / 2) % MOD) % MOD << endl;
        }
    }
    return 0;
}