#MMA Contest 015 F

'''
転倒数の期待値を考える問題、と読み替えないときっついな。
下から挿入して、挿入位置より右側に何個小さい数が起きえるか、で場合分けかな。

[1,2,3,4]の順列で、3を固定した場合
[1,2,3,4] [1,4,3,2]
[2,1,3,4] [2,4,3,1]
[4,1,3,2] [4,2,3,1] の6パターン、合計17個になる。

[x,x,3,x] ここに1を入れる。どこに入れても転倒しない。
[x,x,3,x] ここに2を入れる。挿入箇所より右に1がある場合の数は 2!*1 通り。
[x,x,3,x] ここに3を入れる。挿入箇所より右に1か2がある場合の数は ...
          自由マス1マスに対して1か2が入るパターンだから2通り、ではないんですね。
          アタリが2個、ハズレが1個。1個だけ球をとる。期待値は？2/3
          並び方の場合の数は？3!通り。うん、これでなんとかなる。

なんともならなかったので解説。
X,Yを固定し、答えへの寄与度を考える必要があったらしい。うーん、難しい。
'''

#Segment Tree: O(logN)
class SegmentTree:                                    # Segment Tree
    def __init__(self,n,identity_e,combine_f):        # 適応条件: 単位元eがある、互換可能
        self._n=n; self._size=1                       # モノイド(単位元)の例:
        while self._size<self._n:self._size<<=1       #  足し算 0, かけ算 1, 最小 INF,
        self._identity_e=identity_e                   #  最大 -INF, LCM(最小公倍数) 1
        self._combine_f=combine_f                     #
        self._node=[self._identity_e]*2*self._size    # combine_f には関数を指定する
                                                      # def文で関数を自作してもいいし、
    def build(self,array):                            #  from operator import xor
        assert len(array)==self._n,'array too large'  # のようにimportしてもよい
        for i,v in enumerate(array,start=self._size): #
            self._node[i]=v                           # build: セグ木を建てる
        for i in range(self._size-1,0,-1):            # 異常時はassert関数でエラーを報告
            self._node[i]=self._combine_f(self._node[i<<1|0],self._node[i<<1|1])
                                                      #
    def update(self,index,value):                     # update: 一点更新 O(logN)
        i=self._size+index; self._node[i]=value       # 地点i(0-indexed)を更新する
        while i-1:                                    # 同時に上位のセグメントも更新する
            i>>=1                                     #
            self._node[i]=self._combine_f(self._node[i<<1|0],self._node[i<<1|1])
                                                      #
    def fold(self,L,R):                               # fold: 区間取得 O(logN)
        L+=self._size; R+=self._size                  # 区間 [L,R) の特定値を取得する
        vL,vR=[self._identity_e]*2                    #
        while L<R:                                    # nodeの遷移の考え方
            if L&1:                                   #  ---1---  L: 自身より右の最小
                vL=self._combine_f(vL,self._node[L])  #  -2- -3-  R: 自身-1より左の最小
                L+=1                                  #  4 5 6 7  Rは計算より先に-1の
            if R&1:                                   #           処理をする点に注意
                R-=1                                  # R---1---L
                vR=self._combine_f(self._node[R],vR)  # R-2- LLL. 例: L=6, R=5
            L>>=1; R>>=1                              # .R.5 L 7      Rの移動が変則的
        return self._combine_f(vL,vR)                 #  ←R L→


add=lambda x,y:x+y
f=lambda:list(map(int,input().split()))

#入力受取  fact[i]: i! mod MOD
N,M=f(); MOD=998244353; Fixed={p:k for p,k in [f() for _ in range(M)]}; fact=[1]*(N+1)+[0]
for i in range(1,N+1): fact[i]=(fact[i-1]*i)%MOD

#LowerFix[i]: iより小さく、iよりも右にある(転倒に寄与する)固定された値の個数
#Free[i]: iより小さい自由マスの個数
ST=SegmentTree(N+1,0,add); LowerFix=dict(); P=[0]+[1]*N; Free=[0]*2+[1]*N
for i in sorted(Fixed.keys()):
    ST.update(Fixed[i],1); LowerFix[i]=ST.fold(Fixed[i]+1,N+1); P[Fixed[i]]=0; Free[i+1]=0
for i in range(1,N+1): Free[i]+=Free[i-1]

#ST[i]: 自由マスなら1(True)とした配列Pをセグ木に乗せたもの
ST=SegmentTree(N+1,0,add); ST.build(P); ans=0
for i in range(1,N+1):
    if i not in Fixed:  #自由マスの場合、自分より小さいYに対して配列を定める
        ans+=Free[i]*(N-M)*(N-M-1)//2%MOD*fact[N-M-2]%MOD; ans%=MOD
    else:  #固定マスの場合、Yが自由か固定かで場合分けする
        LFree=Free[i]; UFree=N-M-LFree
        #寄与1: 小さい値が自分より右側の自由マスに入る
        ans+=LFree*ST.fold(Fixed[i]+1,N+1)%MOD*fact[N-M-1]%MOD; ans%=MOD
        #寄与2: 大きい値が自分より左側の自由マスに入る
        ans+=UFree*ST.fold(0,Fixed[i])%MOD*fact[N-M-1]%MOD; ans%=MOD
        #寄与3: 小さい固定値が右側にある
        ans+=LowerFix[i]*fact[N-M]%MOD; ans%=MOD
print(ans)