#include <bits/stdc++.h>
#if __has_include(<atcoder/all>)
#include <atcoder/all>
std::istream &operator>>(std::istream &is, atcoder::modint &v) {
    long long value;
    is >> value;
    v = value;
    return is;
}
std::ostream &operator<<(std::ostream &os, const atcoder::modint &v) {
    os << v.val();
    return os;
}
std::ostream &operator<<(std::ostream &os, const atcoder::modint998244353 &v) {
    os << v.val();
    return os;
}
std::istream &operator>>(std::istream &is, atcoder::modint998244353 &v) {
    long long x;
    is >> x;
    v = x;
    return is;
}
std::ostream &operator<<(std::ostream &os, const atcoder::modint1000000007 &v) {
    os << v.val();
    return os;
}
std::istream &operator>>(std::istream &is, atcoder::modint1000000007 &v) {
    long long x;
    is >> x;
    v = x;
    return is;
}
#endif

using namespace std;
using ll = long long;
using lint = __int128_t;
using pll = pair<ll, ll>;
#define newl '\n';
#define rep(i, s, t) for (ll i = s; i < (ll)(t); i++)
#define rrep(i, s, t) for (ll i = (ll)(t) - 1; i >= (ll)(s); i--)
#define all(x) begin(x), end(x)
#define SZ(x) ll(x.size())
#define eb emplace_back
#define pb push_back
#define TT template <typename T>
TT using vec = vector<T>;
TT using vvec = vec<vec<T>>;
TT using vvvec = vec<vvec<T>>;
TT using minheap = priority_queue<T, vector<T>, greater<T>>;
TT using maxheap = priority_queue<T>;
TT bool chmin(T &x, T y) {
    return x > y ? (x = y, true) : false;
}
TT bool chmax(T &x, T y) {
    return x < y ? (x = y, true) : false;
}
TT T smod(T x, T mod) {
    x %= mod;
    if (x < 0)
        x += mod;
    return x;
}
TT bool rng(T l, T x, T r) {
    return l <= x && x < r;
}
TT T flr(T a, T b) {
    if (b < 0)
        a = -a, b = -b;
    return a >= 0 ? a / b : (a + 1) / b - 1;
}

TT T cil(T a, T b) {
    if (b < 0)
        a = -a, b = -b;
    return a > 0 ? (a - 1) / b + 1 : a / b;
}
TT T sqr(T x) {
    return x * x;
}

//{0, 1, ... } -> {p[0], p[1], ...}
template <typename T, typename S>
void rearrange(vector<T> &A, vector<S> const &p) {
    assert(p.size() == A.size());
    vector<T> a = A;
    for (int i = 0; i < ssize(A); ++i) {
        a[i] = A[p[i]];
    }
    swap(a, A);
}
template <typename T, typename S, typename... Ts>
void rearrange(vector<T> &A, vector<S> p, vector<Ts> &...rest) {
    rearrange(A, p);
    (rearrange(rest, p), ...);
}
template <typename T, typename Compare, typename... Ts>
void rearrange(vector<T> &A, Compare cmp, vector<Ts> &...rest) {
    vector<int> p(ssize(A));
    iota(p.begin(), p.end(), 0);
    sort(p.begin(), p.end(), cmp);
    rearrange(A, p);
    (rearrange(rest, p), ...);
}
struct io_setup {
    io_setup() {
        ios::sync_with_stdio(false);
        std::cin.tie(nullptr);
        cout << fixed << setprecision(15);
    }
} io_setup;

template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
    os << p.first << " " << p.second;
    return os;
}

TT ostream &operator<<(ostream &os, const vector<T> &v) {
    for (size_t i = 0; i < v.size(); i++) {
        os << v[i] << (i + 1 != v.size() ? " " : "");
    }
    return os;
}

template <typename T, size_t n>
ostream &operator<<(ostream &os, const array<T, n> &v) {
    for (size_t i = 0; i < n; i++) {
        os << v[i] << (i + 1 != n ? " " : "");
    }
    return os;
}

template <typename T> ostream &operator<<(ostream &os, const vvec<T> &v) {
    for (size_t i = 0; i < v.size(); i++) {
        os << v[i] << (i + 1 != v.size() ? "\n" : "");
    }
    return os;
}

TT istream &operator>>(istream &is, vector<T> &v) {
    for (size_t i = 0; i < v.size(); i++) {
        is >> v[i];
    }
    return is;
}

#if __has_include(<debug/debug.hpp>)
#include <debug/debug.hpp>
#else
#define dbg(...) true
#define DBG(...) true
#define OUT(...) true
#endif
struct notlinear_sieve {
    int n;
    vector<int> sm;

    notlinear_sieve(int max_n) : n(max_n), sm(max_n + 1) {
        assert(1 <= n);
        iota(sm.begin(), sm.end(), 0);
        if (n >= 2)
            sm[2] = 2;
        for (int j = 4; j <= n; j += 2)
            sm[j] = 2;
        for (int i = 3; i * i <= n; i += 2) {
            if (sm[i] != i)
                continue;
            for (int j = i * 2; j <= n; j += i) {
                if (sm[j] == j)
                    sm[j] = i;
            }
        }
    }

    bool is_prime(int v) const noexcept {
        assert(v <= n);
        if (v <= 1)
            return false;
        return sm[v] == v;
    }

    vector<int> primes(int max_n) const noexcept {
        assert(1 <= max_n && max_n <= n);
        vector<int> ret;
        for (int i = 2; i <= max_n; i++)
            if (is_prime(i))
                ret.push_back(i);
        return ret;
    }

    // sorted
    vector<pair<int, int>> factorize(int v) const noexcept {
        assert(1 <= v && v <= n);
        vector<pair<int, int>> ret;
        while (sm[v] != v) {
            int tmp = v;
            int c = 0;
            while (tmp % sm[v] == 0)
                c++, tmp /= sm[v];
            ret.emplace_back(sm[v], c);
            v = tmp;
        }
        if (v != 1)
            ret.emplace_back(v, 1);
        return ret;
    }

    int divcnt(int v) const noexcept {
        assert(1 <= v && v <= n);
        auto ps = factorize(v);
        int ret = 1;
        for (auto [p, c] : ps)
            ret *= (c + 1);
        return ret;
    }

    // not sorted
    vector<int> divs(int v) const noexcept {
        assert(1 <= v && v <= n);
        auto ps = factorize(v);
        int sz = 1;
        for (auto [p, c] : ps)
            sz *= (c + 1);
        vector<int> ret(sz);
        ret[0] = 1;
        int r = 1;
        for (auto [p, c] : ps) {
            int nr = r;
            for (int j = 0; j < c; j++) {
                for (int k = 0; k < r; k++) {
                    ret[nr] = p * ret[nr - r];
                    nr++;
                }
            }
            r = nr;
        }
        return ret;
    }

    // 偶数...+1 奇数...-1 p^2...0
    template <typename T> vector<T> mobius(int N) const {
        assert(N <= n);
        vector<T> ret(N + 1, 1);
        for (int p = 2; p <= N; p++)
            if (is_prime(p)) {
                for (int q = p; q <= N; q += p) {
                    if ((q / p) % p == 0)
                        ret[q] = 0;
                    else
                        ret[q] = -ret[q];
                }
            }
        return ret;
    }

    // 以下4つは素因数ごとの累積和と思うと良い。計算量はO(nloglogn)
    // zeta_transform... 結合則 + 交換則 ならなんでも乗る
    // mobius_transform ... 結合 + 交換 + 逆元の存在 ならなんでも乗る
    // f -> F   約数の添字をadd
    template <typename T> vector<T> divisor_zeta_transform(vector<T> A) const {
        int N = int(A.size()) - 1;
        assert(N <= n);
        for (int p = 2; p <= N; p++) {
            if (is_prime(p)) {
                for (int k = 1; k * p <= N; k++) {
                    A[k * p] += A[k];
                }
            }
        }
        return A;
    }

    // F -> f
    template <typename T>
    vector<T> divisor_mobius_transform(vector<T> A) const {
        int N = int(A.size()) - 1;
        assert(N <= n);
        for (int p = 2; p <= N; p++) {
            if (is_prime(p)) {
                for (int k = N / p; k >= 1; k--) {
                    A[k * p] -= A[k];
                }
            }
        }
        return A;
    }

    // f -> F 倍数の添字をadd
    template <typename T> vector<T> multiple_zeta_transform(vector<T> A) const {
        int N = int(A.size()) - 1;
        assert(N <= n);
        for (int p = 2; p <= N; p++) {
            if (is_prime(p)) {
                for (int k = N / p; k >= 1; k--) {
                    A[k] += A[k * p];
                }
            }
        }
        return A;
    }

    // F -> f
    template <typename T>
    vector<T> multiple_mobius_transform(vector<T> A) const {
        int N = int(A.size()) - 1;
        assert(N <= n);
        for (int p = 2; p <= N; p++) {
            if (is_prime(p)) {
                for (int k = 1; k <= N / p; k++) {
                    A[k] -= A[k * p];
                }
            }
        }
        return A;
    }
};
template <class T> struct fenwick_tree {
  public:
    fenwick_tree() : n(0) {
    }
    explicit fenwick_tree(int n) : n(n), data(n), raw(n, T()), S(T()) {
    }

    void add(int p, T x) {
        assert(0 <= p && p < n);
        raw[p] += x;
        S += x;

        p++;
        while (p <= n) {
            data[p - 1] += x;
            p += p & -p;
        }
    }

    T sum(int r) const {
        T s = 0;
        while (r > 0) {
            s += data[r - 1];
            r -= r & -r;
        }
        return s;
    }

    T prod(int l, int r) const {
        assert(0 <= l && l <= r && r <= n);
        return sum(r) - sum(l);
    }

    T all_prod() const {
        return S;
    }

    T get(int p) const {
        return raw[p];
    }

    template <class F> int max_right(F f) const {
        assert(f(0));
        T s = 0;
        int p = 0;
        for (int i = 32 - __builtin_clz(n) - 1; i >= 0; i--) {
            int k = p + (1 << i);
            if (k <= n && f(s + data[k - 1])) {
                s += data[k - 1];
                p = k;
            }
        }
        return p;
    }

  private:
    int n;
    vector<T> data;
    vector<T> raw;
    T S;
};

const ll M = 1'000'000;
notlinear_sieve sieve(M+10);

int main() {
    ll q;
    cin >> q;
    fenwick_tree<ll> fen(M+10);

    vector ls(M + 10,  vector<pll>());
    vector<ll> ans(q, -1);

    rep(qi, 0, q) {
        ll l, r;
        cin >> l >> r;
        r++;
        ls[r].eb(l, qi);
    }

    rep(r, 1, M + 2) {
        for (auto [l, i] : ls[r]) {
            ans[i] = fen.prod(l, r);
        }

        fen.add(r, 1);

        // rの最大の約数は？
        if(r==1) continue;
        auto ds = sieve.divs(r);
        sort(all(ds));
        reverse(all(ds));
        fen.add(ds[1], -1);
    }

    for(auto v : ans) cout << v << newl;
}

/*
同じ議論を繰り返さない
do smth instead of nothing and stay organized
WRITE STUFF DOWN
DON'T GET STUCK ON ONE APPROACH
*/