#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
const long double pi = acos(-1.0);
const int_fast64_t mod = 998244353;
struct pr {
  int_fast64_t x = 0;
  int_fast64_t y = 0;
  int_fast64_t dst = 0;
  pr() {}
  pr(int_fast64_t x, int_fast64_t y, int_fast64_t dst) : x(x), y(y), dst(dst) {}
  inline bool operator<(const pr& cmp2) const {
    if (dst != cmp2.dst) return dst < cmp2.dst;
    if (x != cmp2.x) return x < cmp2.x;
    return y < cmp2.y;
  }
  inline bool operator==(const pr& cmp2) const {
    return (cmp2.dst == dst) && (cmp2.x == x) && (cmp2.y == y);
  }
  inline bool operator>(const pr& cmp2) const {
    if (dst != cmp2.dst) return dst > cmp2.dst;
    if (x != cmp2.x) return x > cmp2.x;
    return y > cmp2.y;
  }
};
struct point {
  int_fast64_t x = 0;
  int_fast64_t y = 0;
  point() {}
  point(int_fast64_t x, int_fast64_t y) : x(x), y(y) {}
  inline bool operator<(const point& cmp2) const {
    if (cmp2.x != x) return cmp2.x < x;
    return cmp2.y < y;
  }
  inline bool operator==(const point& cmp2) const {
    return (cmp2.x == x) && (cmp2.y == y);
  }
  inline bool operator>(const point& cmp2) const {
    if (cmp2.x != x) return cmp2.x > x;
    return cmp2.y > y;
  }
};
namespace std {
template <typename T>
struct hash<vector<T> > {
  size_t operator()(const vector<T>& k) const {
    size_t ret = 0xf3ee477d;
    for (size_t i = 0; i != k.size(); ++i) ret ^= hash(hash(k[i]) + i);
    return ret;
  }
};
template <>
struct hash<pr> {
  size_t operator()(const pr& cmp1) const {
    return (hash<int_fast64_t>()(cmp1.x)) ^ (hash<int_fast64_t>()(cmp1.y)) ^
           (hash<int_fast64_t>()(cmp1.dst));
  }
};
template <>
struct hash<point> {
  size_t operator()(const point& cmp1) const {
    return (hash<int_fast64_t>()(cmp1.x)) ^ (hash<int_fast64_t>()(cmp1.y));
  }
};
}  // namespace std
inline bool spoint(const point& cmp1, const point& cmp2) {
  if (cmp1.x != cmp2.x) return cmp1.x < cmp2.x;
  return cmp1.y < cmp2.y;
}
inline bool spr(const pr& cmp1, const pr& cmp2) {
  if (cmp1.dst != cmp2.dst) return cmp1.dst < cmp2.dst;
  if (cmp1.x != cmp2.x) return cmp1.x < cmp2.x;
  return cmp1.y < cmp2.y;
}
void sub() {}
template <int_fast64_t maxn>
struct fen {
  int_fast64_t* tree = new int_fast64_t[maxn];
  fen() {
    for (int_fast32_t i = (int_fast32_t)0; i < (int_fast32_t)maxn; ++i) {
      tree[i] = 0;
    }
  }
  void del() { delete tree; }
  void add(int_fast64_t i, int_fast64_t val) {
    ++i;
    while (i <= maxn) {
      tree[i] = (tree[i] + val) % mod;
      i += i & (-i);
    }
  }
  int_fast64_t get(int_fast64_t i) {
    ++i;
    int_fast64_t ans = 0;
    while (i > 0) {
      ans = (ans + tree[i]) % mod;
      i -= i & (-i);
    }
    return ans;
  }
};
fen<200005> dp;
int_fast64_t n, k;
void solve() {
  cin >> n >> k;
  vector<point> cmd;
  for (int_fast32_t i = (int_fast32_t)0; i < (int_fast32_t)k; ++i) {
    int_fast64_t l, r;
    cin >> l >> r;
    cmd.push_back({l, r});
  }
  dp.add(1, 1);
  for (int_fast32_t i = (int_fast32_t)2; i < (int_fast32_t)n + 1; ++i) {
    int_fast64_t res = 0;
    for (int_fast32_t j = (int_fast32_t)0; j < (int_fast32_t)k; ++j) {
      if (i - cmd[j].x < 0) continue;
      res = (res + dp.get(i - cmd[j].x));
      if (i - cmd[j].y - 1 >= 0) {
        res = ((res - dp.get(i - cmd[j].y - 1)) % mod + mod) % mod;
      }
    }
    dp.add(i, res);
  }
  cout << dp.get(n) - dp.get(n - 1) << endl;
}
void init() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  srand(time(0));
}
int main() {
  init();
  solve();
  return 0;
}
