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 Kotlin (1.3.71) (judge verdict: Accepted)

import java.io.*
import java.util.*
import java.lang.*
import java.lang.Math.*


class SegTreeSum(val N: Int, val Mod: Long = 1_000_000_007L) {
    private var sg = LongArray(0)
    private var sg2 = LongArray(0)
    var size = 0
        private set
    init {
        var sz = 1
        while (sz < N) {
            sz = sz shl 1
        }
        this.size = sz
        sg = LongArray(sz shl 1){0}
        sg2 = LongArray(sz shl 1){0}
    }
    fun add(i: Int, j: Int, X: Long, v: Int = 0, l: Int = 0, r:Int = this.size) {
        if (r <= i || j <= l) {
            return
        }
        if (i <= l && r <= j) {
            this.sg2[v] += X

            this.sg2[v] %= Mod
        } else {
            sg[v] += (min(j, r) - max(i, l)) * X

            sg[v] %= Mod

            val m = (l + r) / 2
            add(i, j, X, v * 2 + 1, l, m)
            add(i, j, X, v * 2 + 2, m, r)
        }
    }
    fun add(i: Int, X: Long) {
        add(i, i+1, X)
    }
    fun sum(i: Int, j: Int, v: Int = 0, l: Int = 0, r: Int = this.size): Long {
        if (r <= i || j <= l) {
            return 0L
        } else if (i <= l && r <= j) {
            //return sg[v] + (r - l) * sg2[v]
            var res = sg[v] % Mod
            res += (r - l) * sg2[v] % Mod
            res %= Mod
            return res
        } else {
            val base = (min(j, r) - max(i, l)) * sg2[v]
            val m = (l + r) / 2
            val vl = sum(i, j, 2 * v + 1, l, m)
            val vr = sum(i, j, 2 * v + 2, m, r)
            //return base + vl + vr
            var res = base%Mod
            res += vl
            res %= Mod
            res += vr
            res %= Mod
            return res
        }
    }
    fun get(i: Int): Long {
        return sum(i,i+1)
    }
}

fun solve() {
    val Mod = 998244353L
    val (N, K) = rd.readListInt()
    val LRs = rd.readListIntCols(K).sortedBy { it.first() }
    
    val dp = SegTreeSum(N+5, Mod)
    dp.add(1, 1L)

    for(i in 1 .. N) {
        val now = dp.get(i)%Mod
        if (now == 0L) continue
        
        for ((l,r) in LRs) {
            dp.add(i+l, i+r+1, now%Mod)
        }
    }

    val ans = dp.get(N)%Mod
    println(ans)
}


//val rd = debug.Reader("abc", "179", "d", "sample-1")
val rd = Reader()


fun main(args: Array<String>) {
    try {
        var exception: Throwable? = null
        val sth = Thread(null, SolveThread(), "solveThread", 128 * 1024 * 1024)
        sth.setUncaughtExceptionHandler { _, e -> exception = e }
        sth.start(); sth.join()
        if (exception != null) throw exception!! }
    catch (e: Exception) { throw e }
    finally { rd.close() }
}
const val MOD = 1_000_000_007L; const val INF = Int.MAX_VALUE/2; const val LINF = Long.MAX_VALUE/2
const val EPS = 1e-9; fun DBLEQ(a: Double, b: Double): Boolean {return abs(a - b) < EPS}
data class IntPair(val first: Int, val second: Int); data class LongPair(val first: Long, val second: Long)
data class To(val idx: Int, val cost: Long)
fun <T>edge(V: Int): Array<ArrayList<T>> { return Array(V){ArrayList<T>()} }
val errPrintln: (Any) -> Unit = { msg -> System.err.println(msg) }
fun rAssert(exp: Boolean, lazyMsg: () -> String = {""}) {
    if (!exp) { val msg = lazyMsg(); errPrintln("EAssert Error: $msg"); throw Error(msg) }
}
fun tAssert(exp: Boolean, lazyMsg: () -> String = {""}) {
    if (!exp) { val msg = lazyMsg(); errPrintln("TAssert Error: $msg"); Thread.sleep(3000) }
}
class SolveThread : Runnable {
    override fun run() { solve() }
}
class Reader {
    private val br = BufferedReader(InputStreamReader(System.`in`))
    val readString: () -> String = { br.readLine() }
    val readInt: () -> Int = { br.readLine().toInt() }
    val readLong: () -> Long = { br.readLine().toLong() }
    val readDouble: () -> Double = { br.readLine().toDouble() }
    val readListInt: () -> List<Int> = { br.readLine().split(' ').map { it.toInt() } }
    val readListLong: () -> List<Long> = { br.readLine().split(' ').map { it.toLong() } }
    val readIntArray: () -> IntArray = { readListInt().toIntArray() }
    val readLongArray: () -> LongArray = { readListLong().toLongArray() }
    val readListStringCol: (Int) -> List<String> = { N -> (0 until N).map { readString() } }
    val readListIntCol: (Int) -> List<Int> = { N -> (0 until N).map { readInt() } }
    val readListIntCols: (Int) -> List<List<Int>> = { N -> (0 until N).map { readListInt() } }
    val readListLongCol: (Int) -> List<Long> = { N -> (0 until N).map { readLong() } }
    val readListLongCols: (Int) -> List<List<Long>> = { N -> (0 until N).map { readListLong() } }
    val close: () -> Unit = { br.close() }
    protected fun finalize() { close() }
}