#include <bits/stdc++.h>

using i64 = long long;
using f64 = double;

constexpr int N = 2e3 + 5, P = 998244353;
constexpr f64 EPS = 1e-10;

template<typename T>
T power(T a, i64 b) {
	T ret = 1;
	while (b) {
		if (b & 1) ret = ret * a;
		a = a * a;
		b >>= 1;
	}
	return ret;
}

template<int P>
struct ModInt {
	int val;

	static inline int norm(int x) {
		if (x < 0)  x += P;
		if (x >= P) x -= P;
		return x; 
	}

	ModInt operator - () const { return ModInt(P - val); }
	inline ModInt inv() const { return power(*this, P - 2); }

	ModInt() {}
	ModInt(int val) : val(norm(val % P)) {}
	ModInt(i64 val) : val(norm(val % P)) {}

	bool constexpr operator <  (const ModInt &rhs) const { return val < rhs.val; }
	bool constexpr operator == (const ModInt &rhs) const { return val == rhs.val; }
	bool constexpr operator != (const ModInt &rhs) const { return val != rhs.val; }

	ModInt &operator += (const ModInt &rhs) & { return val = norm(val + rhs.val), *this; }
	ModInt &operator -= (const ModInt &rhs) & { return val = norm(val - rhs.val), *this; }
	ModInt &operator *= (const ModInt &rhs) & { return val = 1ll * val * rhs.val % P, *this; }
	ModInt &operator /= (const ModInt &rhs) & { return *this *= rhs.inv(); }

	ModInt constexpr operator + (const ModInt &rhs) const { ModInt ret = *this; return ret += rhs; }
	ModInt constexpr operator - (const ModInt &rhs) const { ModInt ret = *this; return ret -= rhs; }
	ModInt constexpr operator * (const ModInt &rhs) const { ModInt ret = *this; return ret *= rhs; }
	ModInt constexpr operator / (const ModInt &rhs) const { ModInt ret = *this; return ret /= rhs; }

	friend std::istream& operator >> (std::istream& is, ModInt &rhs) {
        i64 val; is >> val;
        return rhs.val = norm(val % P), is;
    }
    friend constexpr std::ostream& operator << (std::ostream& os, const ModInt &rhs) { 
    	return os << rhs.val; 
    }
};

using Z = ModInt<P>;

int T, n, m;
int l[N], r[N];
std::vector<int> disc;

struct Diff {
	static constexpr int N = 2e5 + 5, M = 2e5 + 5;
	static constexpr f64 INF = 1e18;
	
	struct Edge {
		int u, v, nxt; f64 w;
		Edge(int _u = 0, int _v = 0, f64 _w = 0, int _nxt = 0) { u = _u; v = _v; w = _w; nxt = _nxt; }
	} E[M << 1];
	
	int n, tot, head[N], cnt[N];
	f64 dis[N];
	bool inQueue[N];
	
	void init(int _n) {
		n = _n; tot = 0;
		for (int i = 0; i <= n; i++) head[i] = -1;
	}
	
	void addEdge(int u, int v, f64 w) {
		// std::cout << "d[" << v << "] - d[" << u << "] <= " << w << "\n";
		E[tot] = Edge(u, v, w, head[u]);
		head[u] = tot++;
	}
	
	bool SPFA(int s) {
		for (int i = 0; i <= n; i++) dis[i] = INF, inQueue[i] = 0;
		std::deque<int> q; dis[s] = cnt[s] = 0;
		inQueue[s] = 1; q.push_back(s);
		while (!q.empty()) {
			int u = q.front(); q.pop_front();
			inQueue[u] = 0;
			for (int i = head[u]; ~i; i = E[i].nxt) {
				int v = E[i].v; f64 w = E[i].w;
				if (dis[u] + w < dis[v]) {
					dis[v] = dis[u] + w;
					cnt[v] = cnt[u] + 1;
					if (cnt[v] >= n + 1) return 0;
					if (!inQueue[v]) {
						if (!q.empty() && dis[v] > dis[q.front()]) q.push_back(v);
		                else q.push_front(v);
		                inQueue[v] = 1;
					}
				}
			}
		}
		return 1;
	}
} D; 

bool check(double mid) {
	D.init(2 * m);
	// d_r - d_l <= w
	// d_r <= d_l + w
	// d_r - d_l >= 1
	// d_r - d_l >= 0

	for (int i = 2; i <= (int)disc.size(); i++) D.addEdge(i, i - 1, 0);
	for (int i = 1; i <= m; i++) {
		D.addEdge(l[i], r[i], mid);
		D.addEdge(r[i], l[i], -1);
	}
	for (int i = 1; i <= (int)disc.size(); i++) D.addEdge(0, i, 0);
	return D.SPFA(0);
}

void solve() {
	std::cin >> n >> m; disc.clear();
	for (int i = 1; i <= m; i++) std::cin >> l[i] >> r[i], disc.push_back(l[i] - 1), disc.push_back(r[i]);
	std::sort(disc.begin(), disc.end());
	disc.resize(std::unique(disc.begin(), disc.end()) - disc.begin());
	for (int i = 1; i <= m; i++) {
		l[i] = std::lower_bound(disc.begin(), disc.end(), l[i] - 1) - disc.begin() + 1;
		r[i] = std::lower_bound(disc.begin(), disc.end(), r[i]) - disc.begin() + 1;
	}
	double l = 1, r = n;
	for (int _ = 1; _ <= 100; _++) {
		double mid = (l + r) / 2;
		if (check(mid)) r = mid;
		else l = mid;
	}
	for (int i = 1; i <= (int)disc.size(); i++) {
		double t = l * i;
		if (std::fabs(t - int(t + 0.5)) < EPS) {
			std::cout << Z(int(t + 0.5)) / Z(i) << "\n";
			return;
		}
	}
}

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

	std::cin >> T;
	while (T--) solve();

	return 0;
}