#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

const int MAXN = 4000;
const int INF = 1e9;
const int MOD = 998244353;

int mpow(int a, int b)
{
    int ret=1;
    while(b)
    {
        if(b&1) ret=1ll*ret*a%MOD;
        a=1ll*a*a%MOD; b>>=1;
    }
    return ret;
}

int TC, N, M;
pii A[MAXN+10];
vector<int> adj[MAXN+10];
int dp1[MAXN+10], dp2[MAXN+10];

int main()
{
    ios_base::sync_with_stdio(false); cin.tie(NULL);
    
    scanf("%d", &TC);
    while(TC--)
    {
        scanf("%d%d", &N, &M);
        for(int i=1; i<=M; i++)
        {
            int l, r;
            scanf("%d%d", &l, &r);
            l--;
            A[i]={l, r};
        }

        vector<int> comp;
        for(int i=1; i<=M; i++) comp.push_back(A[i].first), comp.push_back(A[i].second);
        sort(comp.begin(), comp.end());
        comp.erase(unique(comp.begin(), comp.end()), comp.end());
        for(int i=1; i<=M; i++)
        {
            A[i].first=lower_bound(comp.begin(), comp.end(), A[i].first)-comp.begin()+1;
            A[i].second=lower_bound(comp.begin(), comp.end(), A[i].second)-comp.begin()+1;
            adj[A[i].second].push_back(A[i].first);
        }
        N=comp.size();

        ll u=0, d=1;
        for(int i=1; i<=N; i++)
        {
            for(int j=1; j<=N; j++) dp1[j]=dp2[j]=0;

            for(int j=i+1; j<=N; j++)
            {
                dp1[j]=1e9;
                for(auto it : adj[j]) if(it>=i) dp1[j]=min(dp1[j], dp1[it]+1);
            }
            for(int j=i+1; j<=N; j++)
            {
                dp2[j]=dp2[j-1];
                for(auto it : adj[j]) if(it>=i) dp2[j]=max(dp2[j], dp2[it]+1);
            }
            for(int j=i+1; j<=N; j++)
            {
                // dp2[j]/dp1[j]

                // printf("%d %d : %d %d\n", i, j, dp2[j], dp1[j]);
                if(u*dp1[j]<dp2[j]*d)
                {
                    u=dp2[j], d=dp1[j];
                }
            }
        }
        printf("%lld\n", 1ll*u*mpow(d, MOD-2)%MOD);

        for(int i=1; i<=N; i++) adj[i].clear();
    }
}