#include <bits/stdc++.h>

#define rep(i,s,n) for(int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end();

using ll = long long;
using ld = long double;
using ull = unsigned long long;

bool chmin(auto &a, auto b) {
    if(a <= b) return false;
    a = b;
    return true;
}

bool chmax(auto &a, auto b) {
    if(a >= b) return false;
    a = b;
    return true;
}

using namespace std;

template<ll m> struct modint {
    using mint = modint;
    ll a ;
    modint(ll x=0):a((x%m)%m){}
    static constexpr ll mod(){
        return m;
    }
    ll val() const{
        return a;
    }
    ll& val() {
        return a;
    }
    mint pow(ll n) const{
        mint res = 1;
        mint x = a;
        while(n){
            if (n&1) res*=x;
            x*=x;
            n>>=1;
        }
        return res;
    }
    mint inv() const {
        return pow(m-2);
    }
    mint& operator+=(const mint rhs){
        a+=rhs.a;
        if (a>=m)a-=m;
        return *this;
    }
    mint& operator-=(const mint rhs){
        if (a<rhs.a)a+=m;
        a-=rhs.a;
        return *this;
    }
    mint& operator*=(const mint rhs){
        a  = a*rhs.a%m;
        return *this;
    }
    mint& operator/=(mint rhs){
        *this *=rhs.inv();
        return *this;
    }
    friend mint operator+(const mint& lhs, const mint& rhs){
        return mint(lhs) += rhs;
    }
    friend mint operator-(const mint& lhs, const mint& rhs){
        return mint(lhs) -= rhs;
    }
    friend mint operator*(const mint& lhs, const mint& rhs){
        return mint(lhs) *= rhs;
    }
    friend mint operator/(const mint& lhs, const mint& rhs){
        return mint(lhs) /= rhs;
    }
    mint operator+()const {
        return *this;
    }
    mint operator-() const {
        return mint()-*this;
    }
    friend bool operator==(const modint &lhs, const modint &rhs){
        return lhs.a == rhs.a;
    }
    friend bool operator!=(const modint &lhs, const modint &rhs){
        return !(lhs==rhs);
    }
    
};

bool isprime(ll n){
    if (n == 1) return false;
    for (ll i=2; i*i<=n; i++){
        if (n%i == 0) return false;
    }
    return true;
}

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

    int tmp = 0;
    typedef modint<998244353> mint;

    random_device seed_gen;
    mt19937 engine(seed_gen());
    uniform_int_distribution<int> dist((int)7e8, (int)9e8);

    int mod_sub;
    do{
        mod_sub = dist(engine);
    }while(!isprime(mod_sub));

    map<ll,pair<double,int>> mp;

    for (int b=2; b<=16; b++){
        for (int c=1; c<b; c++){
            ll tar_sub = 0;
            mint tar = 0;
            bool mode = 0;
            for (int x=1; x<=100000000; x++){
                if (tar_sub * b + c >= mod_sub) mode = 1;
                tar_sub = (tar_sub * b + c) % mod_sub;
                tar = tar * b + c;
                if(log10(b) * x > 10000){
                    break;
                }
                ll HASH = (tar_sub << 32LL) | tar.val();
                if (mode){
                    mp[HASH] = pair(log10(b) * x  - log10(b-1) + log10(c), mod_sub);
                }else{
                    mp[HASH] = pair(log10(b) * x  - log10(b-1) + log10(c), tar_sub);
                }
            }
        }
    }

    //cout << (int)mp.size() << '\n';
    const ll mask = (1LL<<32)-1;

    vector<ll> smaller;
    vector<pair<double,ll>> larger;
    for (auto [x, y]: mp){
        if (y.second < mod_sub) smaller.push_back(y.second);
        else larger.push_back(pair(y.first, x&mask));
    }

    sort(smaller.begin(), smaller.end());
    sort(larger.begin(), larger.end());

    vector<mint> cons;
    
    for (ll x: smaller) cons.push_back(x);
    for (auto [x, y]: larger){
        //if (x < 20) cout << x << ' ' << y << '\n';
        cons.push_back(y);
    }

    int m = cons.size();
    vector<mint> rui(m + 1);
    rep(i,0,m){
        rui[i+1] = rui[i] + cons[i];
    }

    int q; cin >> q;
    while(q--){
        int l, r; cin >> l >> r;
        l--;
        cout << (rui[r] - rui[l]).val() << '\n';
    }
}