#include <bits/stdc++.h>

template <int m>
struct ModInt {
private:
    int raw_;
public:
    using mint = ModInt;
    using i64 = int64_t;

    ModInt() {
        raw_ = 0;
    }
    template <typename Tp>
    ModInt(const Tp &v) {
        raw_ = v % m;
    }

    int value() const {
        return (raw_ + m) % m;
    }

    mint &operator+=(const mint &rhs) {
        raw_ = (raw_ + rhs.raw_) % m;
        return *this;
    }
    mint &operator-=(const mint &rhs) {
        raw_ = (raw_ - rhs.raw_) % m;
        return *this;
    }
    mint &operator*=(const mint &rhs) {
        raw_ = (i64)raw_ * rhs.raw_ % m;
        return *this;
    }
    mint &operator/=(const mint &rhs) {
        raw_ = (i64)raw_ * qpow(rhs.raw_, m - 2) % m;
        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;
    }

    static int qpow(int a, int b) {
        int res = 1;
        while (b) {
            if (b & 1) {
                res = (i64)res * a % m;
            }
            a = (i64)a * a % m, b >>= 1;
        }
        return res;
    }
};

constexpr int N = 1e6;
constexpr int MOD = 998244353, HELPER_MOD = 1004535989;
using mint = ModInt<MOD>;
using i64 = int64_t;
using i128 = __int128;
using real = long double;

template <typename Z>
constexpr Z qpow(Z a, int b) {
    Z res = 1;
    while (b) {
        if (b & 1) {
            res *= a;
        }
        a *= a, b >>= 1;
    }
    return res;
}

struct Numeric {
    ModInt<MOD> v;
    ModInt<HELPER_MOD> h1;
    real logarithm;
    i64 enig;
    Numeric(int base, int len, int d) {
        v = ModInt<MOD>{ModInt<MOD>::qpow(base, len) - 1} / (base - 1) * d;
        h1 = ModInt<HELPER_MOD>{ModInt<HELPER_MOD>::qpow(base, len) - 1} / (base - 1) * d;

        logarithm = logl(base) * len - logl(base - 1) + logl(d);
        enig = (qpow<i64>(base, len) - 1) / (base - 1) * d;
    }
    bool is_big() const {
        return logarithm > 30;
    }
    ModInt<MOD> value() const {
        return v;
    }
    friend bool operator==(const Numeric &lhs, const Numeric &rhs) {
        return lhs.v.value() == rhs.v.value() &&
            lhs.h1.value() == rhs.h1.value();
    }
    friend bool operator<(const Numeric &lhs, const Numeric &rhs) {
        if (!lhs.is_big() && !rhs.is_big()) {
            return lhs.enig < rhs.enig;
        }
        return lhs.logarithm < rhs.logarithm;
    }
};

struct Base {
    int base;
    int len, d;
    bool valid;
    Numeric num;
    explicit Base(int b) : base(b), len(1), d(1), valid(true), num(base, len, d) {
    }
    void advance() {
        if (d + 1 < base) {
            d += 1;
        } else {
            d = 1;
            len += 1;
        }
        valid = false;
    }
    Numeric get() {
        if (!valid) {
            valid = true;
            num = Numeric{base, len, d};
        }
        return num;
    }
};

int main() {
    std::vector<mint> s(N + 1);

    std::vector<Base> base;
    for (int i = 2; i <= 16; ++i) {
        base.emplace_back(i);
    }

    for (int i = 1; i <= N; ++i) {
        Numeric res{2, N + 1, 1};
        for (auto &b : base) {
            auto x = b.get();
            if (x < res) {
                res = x;
            }
        }
        for (auto &b : base) {
            if (b.get() == res) {
                b.advance();
            }
        }
        s[i] = s[i - 1] + res.value();
    }

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

    int t;
    std::cin >> t;

    while (t--) {
        int l, r;
        std::cin >> l >> r;
        std::cout << (s[r] - s[l - 1]).value() << '\n';
    }
}