#include <bits/stdc++.h>
#include <atcoder/all>
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 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 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>>

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 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);
}

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;
}

template <typename T>
int find_left(vector<T>& v, T elem) {
    return (int)(upper_bound(v.begin(), v.end(), elem) - v.begin()) - 1;
}
template <typename T>
int find_right(vector<T>& v, T elem) {
    return (int)(lower_bound(v.begin(), v.end(), elem) - v.begin());
}

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)); }

template <typename Elem, typename LazyOperand>
class LazySegmentTree {
   public:
    Elem (*f)(Elem a, Elem b);
    Elem (*g)(Elem a, LazyOperand b);
    LazyOperand (*h)(LazyOperand a, LazyOperand b);
    using fTYPE = decltype(f);
    using gTYPE = decltype(g);
    using hTYPE = decltype(h);

    Elem elem_ident;
    LazyOperand lazy_operand_ident;
    vector<Elem> elems;
    vector<LazyOperand> lazy_operands;
    int n, height;

    LazySegmentTree(fTYPE f, gTYPE g, hTYPE h, Elem elem_ident, LazyOperand lazy_operand_ident)
        : f(f), g(g), h(h), elem_ident(elem_ident), lazy_operand_ident(lazy_operand_ident) {}

    void init(int n_temp) {
        n = 1;
        height = 0;
        while (n < n_temp) {
            n <<= 1;
            ++height;
        }
        elems.assign(2 * n, elem_ident);
        lazy_operands.assign(2 * n, lazy_operand_ident);
    }

    void build(const vector<Elem>& v) {
        int n_temp = v.size();
        init(n_temp);
        rep(i, n_temp) elems[n + i] = v[i];
        for (int i = n - 1; i > 0; --i) {
            elems[i] = (*f)(elems[i * 2], elems[i * 2 + 1]);
        }
    }

    inline void assign_merged_lazy(LazyOperand& dest, LazyOperand x) { dest = (*h)(dest, x); }

    inline Elem reflect(int k) {
        return (lazy_operands[k] == lazy_operand_ident) ? elems[k] : (*g)(elems[k], lazy_operands[k]);
    }

    inline void _eval(int k) {
        if (lazy_operands[k] != lazy_operand_ident) {
            assign_merged_lazy(lazy_operands[k * 2], lazy_operands[k]);
            assign_merged_lazy(lazy_operands[k * 2 + 1], lazy_operands[k]);

            elems[k] = reflect(k);
            lazy_operands[k] = lazy_operand_ident;
        }
    }

    inline void eval_down(int k) {
        for (int i = height; i > 0; --i) {
            _eval(k >> i);
        }
    }

    inline void recalc(int k) {
        while (k >>= 1) {
            elems[k] = (*f)(reflect(k * 2), reflect(k * 2 + 1));
        }
    }

    void update(int a, int b, LazyOperand x) {
        a += n;
        b += n;
        eval_down(a);
        eval_down(b - 1);
        for (int l = a, r = b; l < r; l >>= 1, r >>= 1) {
            if (l & 1) assign_merged_lazy(lazy_operands[l++], x);
            if (r & 1) assign_merged_lazy(lazy_operands[--r], x);
        }
        recalc(a);
        recalc(b - 1);
    }

    void set_val(int a, Elem e) {
        a += n;
        eval_down(a);
        elems[a] = e;
        lazy_operands[a] = lazy_operand_ident;
        recalc(a);
    }

    Elem query(int a, int b) {
        a += n;
        b += n;
        eval_down(a);
        eval_down(b - 1);
        Elem vl = elem_ident, vr = elem_ident;
        for (int l = a, r = b; l < r; l >>= 1, r >>= 1) {
            if (l & 1) vl = (*f)(vl, reflect(l++));
            if (r & 1) vr = (*f)(reflect(--r), vr);
        }
        Elem merged = (*f)(vl, vr);
        return merged;
    }

    void desc() {
    }
};

template <typename T>
class SumQueryLazySegTreeBase {
    using Elem = T;
    using LazyOperand = T;
    using Monoid = pair<Elem, int>;

   public:
    LazySegmentTree<Monoid, LazyOperand>* st = nullptr;

   public:
    SumQueryLazySegTreeBase(int size) {}
    SumQueryLazySegTreeBase(vector<Elem>& ar) {}
    virtual ~SumQueryLazySegTreeBase() {
        if (st != nullptr) delete st;
    }

   public:
    void update(int l, int r, LazyOperand x) { st->update(l, r, x); }
    Elem query(int l, int r) { return st->query(l, r).first; }
};

template <typename T>
class MaxQueryLazySegTreeBase {
    using Elem = T;
    using LazyOperand = T;

   public:
    LazySegmentTree<Elem, LazyOperand>* st = nullptr;

   public:
    MaxQueryLazySegTreeBase(int size) {}
    MaxQueryLazySegTreeBase(vector<Elem>& ar) {}
    virtual ~MaxQueryLazySegTreeBase() {
        if (st != nullptr) delete st;
    }

   public:
    void update(int l, int r, LazyOperand x) { st->update(l, r, x); }
    Elem query(int l, int r) { return st->query(l, r).first; }
};

template <typename T>
class MinQueryLazySegTreeBase {
    using Elem = T;
    using LazyOperand = T;

   public:
    LazySegmentTree<Elem, LazyOperand>* st = nullptr;

   public:
    MinQueryLazySegTreeBase(int size) {}
    MinQueryLazySegTreeBase(vector<Elem>& ar) {}
    virtual ~MinQueryLazySegTreeBase() {
        if (st != nullptr) delete st;
    }

   public:
    void update(int l, int r, LazyOperand x) { st->update(l, r, x); }
    Elem query(int l, int r) { return st->query(l, r).first; }
};

template <typename T>
class PlusSumLazySegTree : public SumQueryLazySegTreeBase<T> {
    using Elem = T;
    using LazyOperand = T;
    using Monoid = pair<Elem, int>;

    static Monoid f(Monoid a, Monoid b) { return Monoid(a.first + b.first, a.second + b.second); }
    static Monoid g(Monoid a, LazyOperand b) {
        Elem p = b * a.second;
        return Monoid(a.first + p, a.second);
    }
    static LazyOperand h(LazyOperand a, LazyOperand b) { return a + b; }

   public:
    PlusSumLazySegTree(int size) : SumQueryLazySegTreeBase<T>(size) {
        this->st = new LazySegmentTree<Monoid, LazyOperand>(&f, &g, &h, Monoid((Elem)0, 0), (LazyOperand)0);
        this->st->build(vector<Monoid>(size, Monoid((Elem)0, 1)));
    }
    PlusSumLazySegTree(vector<Elem>& ar) : SumQueryLazySegTreeBase<T>(ar) {
        this->st = new LazySegmentTree<Monoid, LazyOperand>(&f, &g, &h, Monoid((Elem)0, 0), (LazyOperand)0);
        vector<Monoid> tmp(ar.size());
        rep(i, ar.size()) tmp[i] = Monoid(ar[i], 1);
        this->st->build(tmp);
    }
};

using P = atcoder::modint998244353;

ll solve(int N, int K, vi& l, vi& r) {
    PlusSumLazySegTree<P> sg(N + 2);

    sg.update(1, 2, 1);

    int goal = N;
    rep1(i, N) {
        P here = sg.query(i, i + 1);
        rep(j, K) {
            int lo = l[j], hi = r[j] + 1;
            if (i + lo > goal) continue;
            amin(lo, goal);
            amin(hi, goal);
            sg.update(i + lo, i + hi, here);
        }
    }
    return sg.query(goal, goal + 1).val();
}

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;
}
