#include <bits/stdc++.h>

using u32 = unsigned;
using i64 = long long;
using u64 = unsigned long long;
// TODO: Dynamic ModInt

template<typename T>
constexpr T power(T a, u64 b) {
    T res {1};
    for (; b != 0; b /= 2, a *= a) {
        if (b % 2 == 1) {
            res *= a;
        }
    }
    return res;
}

template<u32 P>
constexpr u32 mulMod(u32 a, u32 b) {
    return 1ULL * a * b % P;
}

template<u64 P>
constexpr u64 mulMod(u64 a, u64 b) {
    u64 res = a * b - u64(1.L * a * b / P - 0.5L) * P;
    res %= P;
    return res;
}

template<typename U, U P>
requires std::unsigned_integral<U>
struct ModIntBase {
public:
    constexpr ModIntBase() : x {0} {}
    
    template<typename T>
    requires std::integral<T>
    constexpr ModIntBase(T x_) : x {norm(x_ % T {P})} {}
    
    constexpr static U norm(U x) {
        if ((x >> (8 * sizeof(U) - 1) & 1) == 1) {
            x += P;
        }
        if (x >= P) {
            x -= P;
        }
        return x;
    }
    
    constexpr U val() const {
        return x;
    }
    
    constexpr ModIntBase operator-() const {
        ModIntBase res;
        res.x = norm(P - x);
        return res;
    }
    
    constexpr ModIntBase inv() const {
        return power(*this, P - 2);
    }
    
    constexpr ModIntBase &operator*=(const ModIntBase &rhs) & {
        x = mulMod<P>(x, rhs.val());
        return *this;
    }
    
    constexpr ModIntBase &operator+=(const ModIntBase &rhs) & {
        x = norm(x + rhs.x);
        return *this;
    }
    
    constexpr ModIntBase &operator-=(const ModIntBase &rhs) & {
        x = norm(x - rhs.x);
        return *this;
    }
    
    constexpr ModIntBase &operator/=(const ModIntBase &rhs) & {
        return *this *= rhs.inv();
    }
    
    friend constexpr ModIntBase operator*(ModIntBase lhs, const ModIntBase &rhs) {
        lhs *= rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator+(ModIntBase lhs, const ModIntBase &rhs) {
        lhs += rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator-(ModIntBase lhs, const ModIntBase &rhs) {
        lhs -= rhs;
        return lhs;
    }
    
    friend constexpr ModIntBase operator/(ModIntBase lhs, const ModIntBase &rhs) {
        lhs /= rhs;
        return lhs;
    }
    
    friend constexpr std::ostream &operator<<(std::ostream &os, const ModIntBase &a) {
        return os << a.val();
    }
    
    friend constexpr bool operator==(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() == rhs.val();
    }
    
    friend constexpr bool operator!=(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() != rhs.val();
    }
    
    friend constexpr bool operator<(ModIntBase lhs, ModIntBase rhs) {
        return lhs.val() < rhs.val();
    }
    
private:
    U x;
};

template<u32 P>
using ModInt = ModIntBase<u32, P>;

template<u64 P>
using ModInt64 = ModIntBase<u64, P>;

constexpr u32 P = 998244353;
using Z = ModInt<P>;

void solve() {
    int n, m;
    std::cin >> n >> m;
    
    std::vector<int> l(m), r(m);
    std::vector<int> v;
    v.reserve(2 * m);
    for (int i = 0; i < m; i++) {
        std::cin >> l[i] >> r[i];
        l[i]--;
        v.push_back(l[i]);
        v.push_back(r[i]);
    }
    std::sort(v.begin(), v.end());
    v.erase(std::unique(v.begin(), v.end()), v.end());
    
    for (int i = 0; i < m; i++) {
        l[i] = std::lower_bound(v.begin(), v.end(), l[i]) - v.begin();
        r[i] = std::lower_bound(v.begin(), v.end(), r[i]) - v.begin();
    }
    n = v.size();
    
    double lo = 1, hi = n;
    
    std::vector<std::vector<std::pair<int, double>>> adj(n);
    for (int t = 0; t < 40; t++) {
        double x = (lo + hi) / 2;
        
        adj.assign(n, {});
        for (int i = 1; i < n; i++) {
            adj[i].emplace_back(i - 1, 0.0);
        }
        for (int i = 0; i < m; i++) {
            adj[l[i]].emplace_back(r[i], x);
            adj[r[i]].emplace_back(l[i], -1.0);
        }
        
        std::queue<int> q;
        std::vector<bool> inq(n);
        std::vector<int> cnt(n);
        for (int i = 0; i < n; i++) {
            q.push(i);
            inq[i] = true;
        }
        
        bool ok = true;
        std::vector dis(n, 0.0);
        while (!q.empty()) {
            int x = q.front();
            q.pop();
            inq[x] = false;
            
            if (++cnt[x] > n) {
                ok = false;
                break;
            }
            
            for (auto [y, w] : adj[x]) {
                if (dis[y] > dis[x] + w) {
                    dis[y] = dis[x] + w;
                    if (!inq[y]) {
                        q.push(y);
                        inq[y] = true;
                    }
                }
            }
        }
        
        if (ok) {
            hi = x;
        } else {
            lo = x;
        }
    }
    
    double eps = lo;
    int P = 0, Q = 1;
    for (int q = 1; q <= n; q++) {
        for (auto p : {int(q * lo), int(q * lo) + 1}) {
            if (std::abs(1.0 * p / q - lo) < eps) {
                eps = std::abs(1.0 * p / q - lo);
                P = p;
                Q = q;
            }
        }
    }
    std::cout << Z(P) / Q << "\n";
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    
    int t;
    std::cin >> t;
    
    while (t--) {
        solve();
    }
    
    return 0;
}