#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void getMin(T &a, U b) {
  if (a > b) a = b;
}
template <typename T, typename U>
inline void getMax(T &a, U b) {
  if (a < b) a = b;
}
template <typename T>
vector<T> getVector(const int n) {
  return vector<T>(n);
}
template <typename T>
vector<T> getVector(const int n, const T a) {
  return vector<T>(n, a);
}
template <typename T>
vector<T> getEmptyVector() {
  return vector<T>();
}
template <typename T>
void appendAll(vector<T> &a, vector<T> b) {
  a.insert(a.end(), b.begin(), b.end());
}
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
  return os << "(" << a.first << ", " << a.second << ")";
};
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};
const long long MOD = 998244353;
const int MAXN = 1 << 18;
const int inf = 1 << 27;
const long long llinf = 1LL << 50;
const int NIL = -inf;
int popcount(int x) { return __builtin_popcount(x); }
struct segtree {
  struct DATA {
    int flag;
    int prop;
    int node;
  };
  vector<DATA> dat;
  int n;
  void init(int _n) {
    n = 1;
    while (n < _n) n *= 2;
    dat.resize(2 * n);
    for (int i = 0; i < 2 * n; i++) {
      dat[i].flag = 0;
      dat[i].prop = 0;
      dat[i].node = 0;
    }
  }
  int update(int a, int b, int k, int l, int r, int f, int v) {
    if (f) {
      dat[k].flag = 1;
      dat[k].node += dat[k / 2].prop;
      dat[k].prop += dat[k / 2].prop;
      dat[k].node %= MOD;
      dat[k].prop %= MOD;
    }
    if (r <= a || b <= l) {
      return 0;
    }
    if (a <= l && r <= b) {
      dat[k].flag = 1;
      dat[k].node += v;
      dat[k].prop += v;
      dat[k].node %= MOD;
      dat[k].prop %= MOD;
      return dat[k].node;
    } else {
      int vl = update(a, b, k * 2, l, (l + r) / 2, dat[k].flag, v);
      int vr = update(a, b, k * 2 + 1, (l + r) / 2, r, dat[k].flag, v);
      dat[k].flag = 0;
      return dat[k].node = (vl + vr) % MOD;
    }
  }
  int query(int a, int b, int k, int l, int r, int f) {
    if (f) {
      dat[k].flag = 1;
      dat[k].node += dat[k / 2].prop;
      dat[k].prop += dat[k / 2].prop;
      dat[k].node %= MOD;
      dat[k].prop %= MOD;
    }
    if (r <= a || b <= l) {
      return 0;
    }
    if (a <= l && r <= b) {
      return dat[k].node;
    } else {
      int vl = query(a, b, k * 2, l, (l + r) / 2, dat[k].flag);
      int vr = query(a, b, k * 2 + 1, (l + r) / 2, r, dat[k].flag);
      dat[k].flag = 0;
      return (vl + vr) % MOD;
    }
  }
  int sum(int l, int r) { return query(l, r + 1, 1, 1, n + 1, 0); }
  int getIth(int i) { return sum(i, i); }
  void update(int l, int r, int v) { update(l, r + 1, 1, 1, n + 1, 0, v); }
  void updateIth(int i, int v) { update(i, i, v); }
};
void solve() {
  int N, K;
  cin >> N >> K;
  vector<int> L(K), R(K);
  for (int i = 0; i < K; i++) cin >> L[i] >> R[i];
  segtree segt;
  segt.init(N + 1);
  segt.updateIth(1, 1);
  for (int i = 1; i <= N; i++) {
    int d = segt.getIth(i);
    for (int k = 0; k < K; k++) {
      if (i + L[k] > N) continue;
      segt.update(i + L[k], min(i + R[k], N), d);
    }
  }
  cout << segt.getIth(N) << endl;
}
int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int tc = 1;
  while (tc--) {
    solve();
  }
  return 0;
}
