#include <iostream>
#include <vector>
#include <algorithm>
#include <unordered_map>
using namespace std;

const int maxn = 1000000;


int phi[maxn + 10];
int gvt[maxn + 10];
int f_temp[maxn + 10];
int S1[maxn + 10];


int F[maxn + 10];             
int G_pre[maxn + 10];   
int g_val[maxn + 10];         
bool ispsf[maxn + 10];
int prF[maxn + 10], cnt_sieveF = 0;


unordered_map<int, int> cache;


void init_phi() {
    for (int i = 1; i <= maxn; i++) phi[i] = i;
    for (int i = 2; i <= maxn; i++) {
        if (phi[i] == i) {
            for (int j = i; j <= maxn; j += i) {
                phi[j] = phi[j] / i * (i - 1);
            }
        }
    }
}


void init_F() {
    for (int i = 1; i <= maxn; i++) {
        ispsf[i] = true;
    }
    ispsf[1] = false;
    F[1] = 1;
    g_val[1] = 1;
    for (int i = 2; i <= maxn; i++) {
        if (ispsf[i]) {
            prF[cnt_sieveF++] = i;
            F[i] = i + 1;
            g_val[i] = i + 1;
        }
        for (int j = 0; j < cnt_sieveF; j++) {
            int p = prF[j];
            int num = 1LL * i * p;
            if (num > maxn) break;
            ispsf[num] = false;
            if (i % p == 0) {
                g_val[num] = g_val[i] * p + 1;
                F[num] = F[i] / g_val[i] * g_val[num];
                break;
            } else {
                g_val[num] = p + 1;
                F[num] = F[i] * F[p];
            }
        }
    }
    G_pre[0] = 0;
    for (int i = 1; i <= maxn; i++) {
        G_pre[i] = G_pre[i - 1] + F[i];
    }
}


int getG(int n) {
    if (n <= 0) return 0;
    if (n <= maxn) {
        return G_pre[n];
    }
    if (cache.find(n) != cache.end()) {
        return cache[n];
    }
    int ans = 0;
    int l = 1, r;
    for (; l <= n; l = r + 1) {
        int k = n / l;
        r = n / k;
        int sum_i = (int)(l + r) * (r - l + 1) / 2;
        ans += (int)k * sum_i;
    }
    cache[n] = ans;
    return ans;
}

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

    
    init_phi();
    for (int i = 1; i <= maxn; i++) {
        if (i == 1) {
            gvt[i] = 1;
        } else {
            gvt[i] = (int)i * phi[i] / 2;
        }
    }
    for (int d = 1; d <= maxn; d++) {
        for (int j = d; j <= maxn; j += d) {
            f_temp[j] += gvt[d];
        }
    }
    for (int i = 1; i <= maxn; i++) {
        S1[i] = (int)i * f_temp[i];
    }

    
    init_F();

    
    vector<int> fib;
    fib.push_back(1);
    fib.push_back(1);
    while (fib.back() < 100000) {
        int next_fib = fib[fib.size() - 1] + fib[fib.size() - 2];
        fib.push_back(next_fib);
    }

    int t;
    cin >> t;
    vector<pair<int, int>> que(t);
    for (int i = 0; i < t; i++) {
        cin >> que[i].first >> que[i].second;
    }

    
    vector<int> type(t, 0);
    int cur = 0;
    int fibidx = 0;
    while (cur < t) {
        int num1 = fib[fibidx];
        int end1 = min(cur + num1, t);
        for (int i = cur; i < end1; i++) {
            type[i] = 1;
        }
        cur = end1;
        if (cur < t) {
            type[cur] = 2;
            cur++;
        }
        fibidx++;
    }

    
    for (int i = 0; i < t; i++) {
        int x = que[i].first;
        int y = que[i].second;
        if (type[i] == 1) {
            int ans = S1[y] - S1[x];
            cout << ans << '\n';
        } else {
            int res = getG(y) - getG(x - 1);
            int ans = (int)res;
            cout << ans << '\n';
        }
    }

    return 0;
}