#include<iostream>
#include<algorithm>
#include<vector>
#include<numeric>
#include<string>
#include<cmath>
#include<set>
#include<queue>
#include<deque>
#include<bitset>
#include<iomanip>
#include<cctype>
#include<map>
#include<cstring>
#include<bitset>
#include<cassert>
 
#define rep(i,n) for(int (i)=0;(i)<(n);(i)++)
#define rep2(i,a,b) for (int (i)=a;(i)<(b);(i)++)
#define all(x) (x).begin(),(x).end()
 
using namespace std;
using ll = long long int;
 
const int inf = 1001001000;
const long long int Inf = 1001001001001001000;
 
template<typename T>
void print(vector<T> a){
	for (auto x:a){
		cout << x << " ";
	}
	cout << endl;
}
 
template<typename T>
void print2d(vector<vector<T>> a){
	for (auto v:a){
		for (auto x:v){
			cout << x << " ";
		}
		cout << endl;
	}
}



//mod計算用のクラス
// ModInt a = {1,1000000007}みたいな定義もできる.
//modがデフォルト(1000000007)じゃない場合は(ModInt)a+(int)xみたいなものに注意.左のmodが使われる。デフォルトを書き換えれば大丈夫.
//「各メンバーに対して、コピーコンストラクターあるいは代入演算子を順に呼び出す」 という仕様になっている.
// (int)1 + (ModInt)10 みたいなことは出来ない.非メンバで定義する必要がある（と思う）.
class ModInt{
public:
    long long int x;
    long long int mod;
	ModInt(){}
    ModInt(long long int _x, long long int _mod = 998244353){
        this->x = ((_x % _mod) + _mod) % _mod;
        this->mod = _mod;
    }
	ModInt operator-() const {
		return ModInt(-this->x, this->mod);
	}
	ModInt operator+(const ModInt &other) const {
		return ModInt(this->x + (other.x % this->mod), this->mod);
	}
	ModInt operator+=(const ModInt &other){
		*this = *this + other;
		return *this;
	}
	ModInt operator-(const ModInt &other) const {
		long long int res = this->x - (other.x % this->mod);
		if (res < 0) return ModInt(res + this->mod, this->mod);
		return ModInt(res, this->mod);
	}
	ModInt operator-=(const ModInt &other) {
		*this = *this - other;
		return *this;
	}
	ModInt operator*(const ModInt &other) const {
		return ModInt(this->x * (other.x % this->mod),this->mod);
	}
	ModInt operator*=(const ModInt &other) {
		*this = *this * other;
		return *this;
	}
	ModInt operator/(const ModInt &other) const {
		return ModInt(*this * other.inv());
	}
	ModInt operator/=(const ModInt &other) {
		*this = *this / other;
		return *this;
	}
	ModInt pow(long long int n) const {
		ModInt res(1, this->mod), a(this->x, this->mod);
		while (n){
			if (n & 1){
				res = res * a;
			}
			n >>= 1;
			a = a * a;
		}
		return res;
	}
	ModInt inv() const {
		return ModInt(this->pow(this->mod - 2));
	}
	void disp(){
		cout << this->x << endl;
	}
};
ostream& operator<<(ostream& stream, const ModInt m){
	stream << to_string(m.x);
	return stream;
}


ll mod = 998244353;
// struct LazySegmentTree {
// private:
//     int n;
//     vector<ModInt> node, lazy;

// public:
//     LazySegmentTree(vector<ModInt> v) {
//         int sz = (int)v.size();
//         n = 1; while(n < sz) n *= 2;
		
// 		node.resize(2 * n - 1);
// 		lazy.resize(2 * n - 1, 0);

// 		for(int i=0; i<sz; i++) node[i+n-1] = v[i];
// 		cout << "test1" << endl;
//         for(int i=n-2; i>=0; i--){
// 			// cout << node[i * 2 + 1] +  node[i * 2 + 2] << endl;
// 			cout << node[i * 2 + 1] << " " <<  node[i * 2 + 2] << endl;
// 			node[i] = node[i * 2 + 1] + node[i * 2 + 2];
// 		} 
// 		cout << "test2" << endl;
//     }

//     void eval(int k, int l, int r) {
//         if(lazy[k].x != 0) {
//             node[k] += lazy[k];
//             if(r - l > 1) {
//                 lazy[2*k+1] += lazy[k] / 2;
//                 lazy[2*k+2] += lazy[k] / 2;
//             }
//             lazy[k] = 0;
//         }
//     }

//     void add(int a, int b, ModInt x, int k=0, int l=0, int r=-1) {
//         if(r < 0) r = n;
//         eval(k, l, r);
//         if(b <= l || r <= a) return;
//         if(a <= l && r <= b) {
//             lazy[k] += ModInt((r - l) * x.x);
//             eval(k, l, r);
//         }
//         else {
//             add(a, b, x, 2*k+1, l, (l+r)/2);
//             add(a, b, x, 2*k+2, (l+r)/2, r);
//             node[k] = node[2*k+1] + node[2*k+2];
//         }
//     }

//     ModInt getsum(int a, int b, int k=0, int l=0, int r=-1) {
//         if(r < 0) r = n;
//         eval(k, l, r);
//         if(b <= l || r <= a) return 0;
//         if(a <= l && r <= b) return node[k];
//         ModInt vl = getsum(a, b, 2*k+1, l, (l+r)/2);
//         ModInt vr = getsum(a, b, 2*k+2, (l+r)/2, r);
//         return vl + vr;
//     }
// };

struct LazySegmentTree {
private:
    int n;
    vector<ll> node, lazy;

public:
    LazySegmentTree(vector<ll> v) {
        int sz = (int)v.size();
        n = 1; while(n < sz) n *= 2;
        node.resize(2*n-1);
        lazy.resize(2*n-1, 0);

        for(int i=0; i<sz; i++) node[i+n-1] = v[i];
        for(int i=n-2; i>=0; i--) node[i] = (node[i*2+1]%mod) + (node[i*2+2]%mod);
    }

    void eval(int k, int l, int r) {
        if(lazy[k] != 0) {
            node[k] += lazy[k];
            if(r - l > 1) {
                lazy[2*k+1] += lazy[k] / 2;
				// lazy[2 * k + 1] %= mod;
				lazy[2 * k + 2] += lazy[k] / 2;
				// lazy[2 * k + 2] %= mod;
			}
			lazy[k] = 0;
        }
    }

    void add(int a, int b, ll x, int k=0, int l=0, int r=-1) {
        if(r < 0) r = n;
        eval(k, l, r);
        if(b <= l || r <= a) return;
        if(a <= l && r <= b) {
            lazy[k] += (r - l) * x;
			// lazy[k] %= mod;
			eval(k, l, r);
		}
        else {
            add(a, b, x, 2*k+1, l, (l+r)/2);
            add(a, b, x, 2*k+2, (l+r)/2, r);
            node[k] = (node[2*k+1]%mod) + (node[2*k+2]%mod);
        }
    }

    ll getsum(int a, int b, int k=0, int l=0, int r=-1) {
        if(r < 0) r = n;
        eval(k, l, r);
        if(b <= l || r <= a) return 0;
        if(a <= l && r <= b) return node[k];
        ll vl = getsum(a, b, 2*k+1, l, (l+r)/2) % mod;
        ll vr = getsum(a, b, 2*k+2, (l+r)/2, r) % mod;
        return vl + vr;
    }
};

int main()
{
	int n, k;
	cin >> n >> k;
	// cout << ModInt(0) + ModInt(0) << endl;
	vector<ll> dp(n + 1, 0);

	dp[0] = 1;
	LazySegmentTree lst(dp);
	// print<ModInt>(dp);
	vector<pair<int, int>> a;
	rep(i, k)
	{
		int l, r;
		cin >> l >> r;
		a.push_back(pair<int, int>(l, r));
	}
	rep(i,n-1){
		ll v = lst.getsum(i, i + 1);
		// cout << v << endl;
		rep(j, k)
		{
			pair<int, int> p = a[j];
			int l = min(p.first + i,n);
			int r = min(p.second + i,n);
			// cout << l << " " << r << endl;
			lst.add(l, r + 1, v);
		}
	}
	cout << lst.getsum(n-1, n) << endl;
	return 0;
}

Measured memory_bytes: 14536