#include<bits/stdc++.h>
using namespace std;
#define rep(i,a,b) for(int i=a;i<b;i++)
#define rrep(i,a,b) for(int i=a;i>=b;i--)
#define fore(i,a) for(auto& i:a)
#define ff first 
#define ss second 
#define all(a) begin(a),end(a)
#define allr(a) rbegin(a),rend(a)
#define pb push_back
using ll =long long;
using pii=pair<int,int>;
using pll=pair<ll,ll>;
using vi=vector<int>;
using vll=vector<ll>;
template<class T> inline bool chmin(T& a,T b){return a>b?a=b,1:0;}
template<class T> inline bool chmax(T& a,T b){return a<b?a=b,1:0;}

const int INFI=numeric_limits<int>::max()/2;
const ll INFL=numeric_limits<ll>::max()/2;

template< typename T >
struct BinaryIndexedTree {
private:
  int n;
  vector< T > data;

public:
  BinaryIndexedTree() = default;

  explicit BinaryIndexedTree(int n) : n(n) {
    data.assign(n + 1, T());
  }

  explicit BinaryIndexedTree(const vector< T > &v) :
      BinaryIndexedTree((int) v.size()) {
    build(v);
  }

  void build(const vector< T > &v) {
    assert(n == (int) v.size());
    for(int i = 1; i <= n; i++) data[i] = v[i - 1];
    for(int i = 1; i <= n; i++) {
      int j = i + (i & -i);
      if(j <= n) data[j] += data[i];
    }
  }

  void apply(int k, const T &x) {
    for(++k; k <= n; k += k & -k) data[k] += x;
  }

  T prod(int r) const {
    T ret = T();
    for(; r > 0; r -= r & -r) ret += data[r];
    return ret;
  }

  T prod(int l, int r) const {
    return prod(r) - prod(l);
  }
};
void solve(){
    
}

int main(){
    cin.tie(0)->sync_with_stdio(0);
    const int n=(int)1e6+1;
    int q;cin>>q;
    vi l(q),r(q);
    vector<vector<int>> query(n);
    rep(i,0,q){
        cin>>l[i]>>r[i];
        query[l[i]].pb(i);
    }
    vi ans(q);
    BinaryIndexedTree<int> seg(n);
    rrep(l,n-1,1){
        seg.apply(l,1);
        for(int j=2*l;j<n;j+=l){
            if(seg.prod(j,j+1))seg.apply(j,-1);
        }
        fore(idx,query[l]){
            ans[idx]=seg.prod(l,r[idx]+1);
        }
    }
    rep(i,0,q){
        cout<<ans[i]<<'\n';
    }

    return 0;
}
/*

*/