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

#define NDEBUG
#include <cassert>


typedef long long ll;
typedef long double Double;
typedef unsigned long long ull;
typedef pair<int, int> ii;
typedef pair<ll, ll> llll;
typedef pair<double, double> dd;

typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ii> vii;
typedef vector<vector<ii>> vvii;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<llll> vllll;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<long double> vD;

#define sz(a) int((a).size())
#define pb push_back
#define eb emplace_back
#define FOR(var, from, to) for (int var = (from); var <= (to); ++var)
#define rep(var, n) for (int var = 0; var < (n); ++var)
#define rep1(var, n) for (int var = 1; var <= (n); ++var)
#define repC2(vari, varj, n)                 \
    for (int vari = 0; vari < (n)-1; ++vari) \
        for (int varj = vari + 1; varj < (n); ++varj)
#define repC3(vari, varj, vark, n)                      \
    for (int vari = 0; vari < (n)-2; ++vari)            \
        for (int varj = vari + 1; varj < (n)-1; ++varj) \
            for (int vark = varj + 1; vark < (n); ++vark)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define whole(f, x, ...) ([&](decltype((x)) whole) { return (f)(begin(whole), end(whole), ##__VA_ARGS__); })(x)
#define tr(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define found(s, e) ((s).find(e) != (s).end())
#define mset(arr, val) memset(arr, val, sizeof(arr))
#define mid(x, y) ((x) + ((y) - (x)) / 2)
#define IN(x, a, b) ((a) <= (x) && (x) <= (b))

#define cons make_pair
#define car first
#define cdr second
#define caar first.first
#define cdar first.second
#define cadr second.first
#define cddr second.second
#define tpl make_tuple

#define clamp(v, lo, hi) min(max(v, lo), hi)
#define ABS(x) max((x), -(x))
#define PQ(T) priority_queue<T, vector<T>, greater<T>>
#define V(x) vector<x>
#define VV(x) vector<vector<x>>
#define VVV(x) vector<vector<vector<x>>>
template <class T>
void SORT(T& a) {
    sort(a.begin(), a.end());
}
template <class T>
void REV(T& a) {
    reverse(a.begin(), a.end());
}
template <class T>
int LBIX(const vector<T>& ar, T x) {
    return lower_bound(ar.begin(), ar.end(), x) - ar.begin();
}
template <class T>
int UBIX(const vector<T>& ar, T x) {
    return upper_bound(ar.begin(), ar.end(), x) - ar.begin();
}

template <typename T1, typename T2>
inline void amin(T1& a, T2 const& b) {
    if (a > b) a = b;
}
template <typename T1, typename T2>
inline void amax(T1& a, T2 const& b) {
    if (a < b) a = b;
}
template <typename T1, typename T2>
inline bool chmin(T1& a, T2 const& b) {
    if (a > b) {
        a = b;
        return true;
    } else
        return false;
}
template <typename T1, typename T2>
inline bool chmax(T1& a, T2 const& b) {
    if (a < b) {
        a = b;
        return true;
    } else
        return false;
}
template <typename X, typename T>
auto vectors(X x, T a) {
    return vector<T>(x, a);
}
template <typename X, typename Y, typename Z, typename... Zs>
auto vectors(X x, Y y, Z z, Zs... zs) {
    auto cont = vectors(y, z, zs...);
    return vector<decltype(cont)>(x, cont);
}

template <typename T>
vector<T> make_vector(size_t a, T b) {
    return vector<T>(a, b);
}
template <typename... Ts>
auto make_vector(size_t a, Ts... ts) {
    return vector<decltype(make_vector(ts...))>(a, make_vector(ts...));
}

template <typename T>
void assign_vector(vector<T>& v, size_t a, T b) {
    v.assign(a, b);
}
template <typename V, typename... Ts>
void assign_vector(vector<V>& v, size_t a, Ts... ts) {
    v.assign(a, make_vector(ts...));
}

inline ll square(ll x) { return x * x; }
inline ll gcd(ll a, ll b) {
    while (a) swap(a, b %= a);
    return b;
}
inline ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
template <typename T>
inline T mod(T a, T b) {
    return ((a % b) + b) % b;
}

const long double pi = 3.141592653589793238462643383279502884197;

const ll MOD = 998244353LL;

inline ll ADD(ll x, ll y) { return (x + y) % MOD; }
inline ll SUB(ll x, ll y) { return (x - y + MOD) % MOD; }
inline ll MUL(ll x, ll y) { return x * y % MOD; }
inline ll POW(ll x, ll e) {
    ll v = 1;
    for (; e; x = MUL(x, x), e >>= 1)
        if (e & 1) v = MUL(v, x);
    return v;
}
inline ll INV(ll y) { /*assert(y%MOD!=0);*/
    return POW(y, MOD - 2);
}
inline ll DIV(ll x, ll y) { return MUL(x, INV(y)); }

ll solve(int N, int K, vi& l, vi& r) {
    vll im(N + 3, 0);

    im[0] = 1;
    im[1] = -1;
    int goal = N - 1;
    ll ofs = 0;

    rep(i, N - 1) {
        (ofs += im[i]) %= MOD;
        rep(j, K) {
            int lo = i + l[j], hi = i + r[j] + 1;
            amin(lo, goal + 1);
            amin(hi, goal + 1);
            im[lo] = ADD(im[lo], ofs);
            im[hi] = SUB(im[hi], ofs);
        }
    }
    return (ofs + im[goal]) % MOD;
}

int main() {
    int N, K;
    scanf("%d %d%*c", &N, &K);
    vi l(K), r(K);
    rep(i, K) { scanf("%d %d%*c", &l[i], &r[i]); }
    printf("%lld\n", solve(N, K, l, r));
    return 0;
}


Measured memory_bytes: 4852