Problem:
Score : 400 points

Problem Statement

There are N cells arranged in a row, numbered 1, 2, \ldots, N from left to right.

Tak lives in these cells and is currently on Cell 1. He is trying to reach Cell N by using the procedure described below.

You are given an integer K that is less than or equal to 10, and K non-intersecting segments [L_1, R_1], [L_2, R_2], \ldots, [L_K, R_K].
Let S be the union of these K segments.
Here, the segment [l, r] denotes the set consisting of all integers i that satisfy l \leq i \leq r.

When you are on Cell i, pick an integer d from S and move to Cell i + d. You cannot move out of the cells.

To help Tak, find the number of ways to go to Cell N, modulo 998244353.

Constraints

2 \leq N \leq 2 \times 10^5

1 \leq K \leq \min(N, 10)

1 \leq L_i \leq R_i \leq N

[L_i, R_i] and [L_j, R_j] do not intersect (i \neq j)

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N K
L_1 R_1
L_2 R_2
:
L_K R_K

Output

Print the number of ways for Tak to go from Cell 1 to Cell N, modulo 998244353.

Sample Input 1

5 2
1 1
3 4

Sample Output 1

4

The set S is the union of the segment [1, 1] and the segment [3, 4], therefore S = \{ 1, 3, 4 \} holds.

There are 4 possible ways to get to Cell 5:

1 \to 2 \to 3 \to 4 \to 5,

1 \to 2 \to 5,

1 \to 4 \to 5 and

1 \to 5.

Sample Input 2

5 2
3 3
5 5

Sample Output 2

0

Because S = \{ 3, 5 \} holds, you cannot reach to Cell 5.
Print 0.

Sample Input 3

5 1
1 2

Sample Output 3

5

Sample Input 4

60 3
5 8
1 3
10 15

Sample Output 4

221823067

Note that you have to print the answer modulo 998244353.

Solution in C++ (GCC 9.2.1) (judge verdict: Accepted)

/*** akshaykumar99 ***/
 
#include<bits/stdc++.h> 
using namespace std;
 
const long long MOD = 998244353;
const long double PI = acos(-1);
const long long N = 4e5+1;
 
typedef long long ll;
typedef long double ld;

ll t[4*N], lazy[4*N];

void build(ll a[], ll v, ll tl, ll tr)
{
    if(tl == tr)
        t[v] = a[tl];
    else
    {
        ll tm = (tl + tr) >> 1;
        build(a, v * 2, tl, tm);
        build(a, v * 2 + 1, tm + 1, tr);
        t[v] = min(t[v * 2], t[v * 2 + 1]);
    }
}
void push(ll v)
{
    t[v * 2] = (t[v*2] + lazy[v]) % MOD;
    lazy[v * 2] = (lazy[v * 2] +lazy[v])%MOD;
    t[v * 2 + 1] = (t[v * 2 + 1] + lazy[v])%MOD;
    lazy[v * 2 + 1] =( lazy[v * 2 + 1]+lazy[v]) % MOD;
    lazy[v] = 0;
}

void update(ll v, ll tl, ll tr, ll l, ll r, ll val)
{
    if(l > r)
        return;
    if(l == tl && r == tr)
    {
        t[v] = (t[v] + val)% MOD;
        lazy[v] = (lazy[v] + val) % MOD;
    }
    else
    {
        push(v);
        ll tm=(tl+tr)>>1;
        update(v*2, tl, tm, l, min(r, tm), val);
        update(v*2+1, tm+1, tr, max(l, tm+1), r, val);
        t[v]=min(t[v*2], t[v*2+1]);
    }
}

ll query(ll v, ll tl, ll tr, ll l, ll r)
{
    if(l>r)
        return INT_MAX;
    if(l<=tl && tr<=r)
    {
        return t[v];
    }
    push(v);
    ll tm=(tl+tr)>>1;
    return min(query(v*2, tl, tm, l, min(r, tm)), 
            query(v*2+1, tm+1, tr, max(l, tm+1),r));
}
void test_case()
{
	ll n, k;
	cin >> n >> k;
	vector<pair<ll,ll>> v(k+1);
	for(int i = 1; i <= k; i++)
	{
		cin >> v[i].first >> v[i].second;
	}
	ll nn = 2 * n + 1;
	ll a[nn] = {0};
	build(a, 1, 0, nn-1);
	update(1, 0, nn-1, 1, 1, 1);
	for(int i = 1; i < n; i++)
	{
		ll z = query(1, 0, nn-1, i, i);
		// cout << z << " ";
		if(!z)
			continue;
		for(int j = 1; j <= k; j++)
		{
			// cout << v[j].first << ' ' << v[j].second << '\n';
			update(1, 0, nn-1, i + v[j].first, i+v[j].second, z);
		}
	}
	ll z = query(1, 0, nn-1, n, n);
	cout << z<< '\n';
	
}
 
int32_t main()
{
    ios_base::sync_with_stdio(false);
    cin.tie(NULL); cout.tie(NULL); 
    ll tc=1;
    // cin>>tc;
    while(tc--)
        test_case();
    return 0;
}