#include<bits/stdc++.h>

#define REP(i,s,n) for(int i=s;i<n;++i)
#define rep(i,n) REP(i,0,n)
#define fst first
#define snd second
#define pb push_back
#define ALL(x) x.begin(),x.end()
#define EPS (1e-9)
#define equals(a,b) (fabs((a)-(b))<EPS)

using namespace std;

bool LT(double a,double b) { return !equals(a,b) && a < b; }
bool LTE(double a,double b) { return equals(a,b) || a < b; }

const string YES = "";
const string NO  = "";

typedef long long ll;
typedef pair<int,int> ii;

const ll IINF = LLONG_MAX;
const char EMPTY = 'X';

ll mod = 998244353LL;

struct Node{
  ll value;
  /*
    lazy : 
    A : 加算の遅延 ( ADD )
    S : 区間の要素を指定した値にする遅延 ( SET )

    lazy_coef : 
    区間にいくら加算するのかor何をセットするのかを記録
   */
  char lazy;
  ll lazy_coef; 
  Node(ll value=0,char lazy=EMPTY,ll lazy_coef=0):value(value),lazy(lazy),lazy_coef(lazy_coef){}
};
 
class MixSegmentTree{
public:
  vector<Node> RMQ;
  //vector<int> minimum_dat,maximum_dat;
  int limit,N; // N は要素数
 
  void init(int tmp){
    N = tmp;
    int N_N = 1;
    while(N_N < N)N_N *= 2;
    limit = N_N;
    RMQ.resize(3*limit);
    //minimum_dat.resize(3*limit);
    //maximum_dat.resize(3*limit);
    rep(i,3*limit-1) {
      RMQ[i] = Node();
      //minimum_dat[i] =  IINF;
      //maximum_dat[i] = -IINF;
    }
  }

  /* 
  O(n)でRMQを初期化
  [L,R)
  tuple<int,int,int>(総和、最小値、最大値)
  */
  ll _build(int cur,int L,int R,const vector<ll> &buf){

    if( !( 0 <= cur && cur < 2*limit-1 ) ) return 0;
    if( L == R-1 ){
      if( L >= N ) return 0;
      //各要素の値が一定でない場合 ( 配列に初期値をいれてそれで初期化する場合 )
      //buf[] を用意し値を入れ RMQ[cur].value = buf[L]; とする
      // RMQのL番目の要素をbuf[L]で更新
      RMQ[cur].value = buf[L];
      //各要素が全て同じの場合
      //RMQ[cur] = 0; // RMQ の各要素を０で初期化、 1 なら RMQ[cur] = 1などなど...
      //minimum_dat[cur] = 0;
      //maximum_dat[cur] = 0;
    } else {
      ll vl = _build(cur*2+1,L,(L+R)/2,buf);
      ll vr = _build(cur*2+2,(L+R)/2,R,buf);
      RMQ[cur].value = ( vl + vr ) % mod;
    }
    return RMQ[cur].value;
  }

  //initしてから使用すること!!! でないとlimitに正しい値が入っていません
  void build(const vector<ll> &buf) { _build(0,0,limit,buf); }

  inline void value_evaluate(int index,int L,int R){
    if( RMQ[index].lazy == 'A' ){
      RMQ[index].value += ( ( ( R - L ) * RMQ[index].lazy_coef ) % mod ) ;
      RMQ[index].value %= mod;
    } else if( RMQ[index].lazy == 'S' ){
      RMQ[index].value = ( ( R - L ) * RMQ[index].lazy_coef ) % mod;
      RMQ[index].value %= mod;
    }
  }
   
  inline void lazy_evaluate(int index,int L,int R){
    value_evaluate(index,L,R);
    if( index < limit && RMQ[index].lazy != EMPTY ) {
      if( RMQ[index].lazy == 'A' ) {
        if( RMQ[index*2+1].lazy == EMPTY ) RMQ[index*2+1].lazy = 'A'; 
        if( RMQ[index*2+2].lazy == EMPTY ) RMQ[index*2+2].lazy = 'A';
        ( RMQ[index*2+1].lazy_coef += RMQ[index].lazy_coef ) %= mod;
        ( RMQ[index*2+2].lazy_coef += RMQ[index].lazy_coef ) %= mod;
      } else if( RMQ[index].lazy == 'S') {
        RMQ[index*2+1].lazy = RMQ[index*2+2].lazy = 'S';
        RMQ[index*2+1].lazy_coef = RMQ[index].lazy_coef;
        RMQ[index*2+2].lazy_coef = RMQ[index].lazy_coef;
      }
    }
    RMQ[index].lazy = EMPTY;
    RMQ[index].lazy_coef = 0;
  }
 
  inline void value_update(int index){
    RMQ[index].value = ( RMQ[index*2+1].value + RMQ[index*2+2].value ) % mod;
  }
 
  /*
  //[a,b)に対して、oprを行う
  今みてるレンジ[L,R)
  [a,b)の各要素に対して、
  opr が 'A'ならvを加算 ( ADD )
  opr が 'S'ならvに置換 ( SET )
  */
  void _update(int a,int b,char opr,ll v,int index,int L,int R){
    /*
      RMQ[index].lazy にEMPTY以外の値がセットされているのであれば
      その遅延を子ノードに伝える
    */
    lazy_evaluate(index,L,R);
 
    if( b <= L || R <= a )return;
    if( a <= L && R <= b ){
      /*
        [L,R)が目的の範囲に入ったので、ここで処理を終える ( 今いるノードは更新するが子は更新しない, その代わり遅延を残しておく )
        [今いるノード]            [今いるノード]
        [子供]  [子供]     => [子供,遅延] [子供,遅延]
        子供の値は変化しない
        後にその子供を訪れた際に遅延を見て処理を行う
      */
      RMQ[index].lazy = opr; // 今いるノードに遅延を設定して処理をしてもらう
      if( opr == 'A' )      RMQ[index].lazy_coef += v; 
      else if( opr == 'S' ) RMQ[index].lazy_coef = v; 
      lazy_evaluate(index,L,R);
      return;
    }
 
    _update(a,b,opr,v,index*2+1,L,(L+R)/2);
    _update(a,b,opr,v,index*2+2,(L+R)/2,R);
    value_update(index);
 
  }

  // [a,b) に対して opr を行う
  void update(int a,int b,char opr,ll v){ _update(a,b,opr,v,0,0,limit); } 

  ll _query(int a,int b,int index,int L,int R){
    lazy_evaluate(index,L,R); //子ノードにまだ正しい値が入っていない(遅延している)可能性があるので評価して正しい値を入れる
 
    if( b <= L || R <= a ) return 0;
    if( a <= L && R <= b ) return RMQ[index].value%mod;


    auto tmp1 = _query(a,b,index*2+1,L,(L+R)/2);
    auto tmp2 = _query(a,b,index*2+2,(L+R)/2,R);
    ll ret = (tmp1+tmp2)%mod;
    value_update(index); //ここまでくると子の値が正しくなっているのでその和をとって今いるノードにも正しい値をいれる
    return ret;
  }

  // [a,b) の総和、最小値、最大値を返す
  ll query(int a,int b) { return _query(a,b,0,0,limit); }

};

#define MAX 200010

MixSegmentTree dp;

void solve() {

}

int main() {
  int n,K;
  cin >> n >> K;
  vector<ii> seg(K);
  rep(i,K) {
    cin >> seg[i].fst >> seg[i].snd;
  }
  {
    vector<ll> zeros(n+1,0);
    dp.init(n+1);
    dp.build(zeros);
  }
  dp.update(0,1,'A',1);
  REP(i,1,n) {
    ll sum = 0;
    rep(j,K) {
      int L = i - seg[j].snd;
      int R = i - seg[j].fst + 1;
      L = max(L,0);
      R = max(R,0);
      if( !( 0 <= L && L < n && 0 <= R && R < n ) ) continue;
      ll v = dp.query(L,R);
      //cout << "  " << L << "-" << R << " : " << v << endl;
      sum += v;
      sum %= mod;
    }
    //cout << "*i=" << i+1 << " : " << sum << endl;
    dp.update(i,i+1,'S',sum);
  }
  cout << dp.query(n-1,n) << endl;

  return 0;
}


Measured memory_bytes: 23344