import java.lang.Math

class IntSegmentTree(n: Int, private val init: Int, private val func: (Int, Int) -> Int) {
    private var size = 1

    init {
        while (size < n) {
            size *= 2
        }
    }

    private val segTree = IntArray(size * 2 - 1) { init }

    // 指定要素を更新
    fun update(x: Int, value: Int) {
        var tmp = x + size - 1

        segTree[tmp] = value
        while (tmp > 0) {
            tmp = (tmp - 1) / 2
            segTree[tmp] = func(segTree[2 * tmp + 1], segTree[2 * tmp + 2])
        }
    }

    // [a, b)の関数適用結果を取得
    // bが開区間であることに注意
    fun get(a: Int, b: Int, k: Int = 0, l: Int = 0, r: Int = size): Int {
        if (r <= a || b <= l) {
            return init
        }
        if (a <= l && r <= b) {
            return segTree[k]
        }

        val vl = get(a, b, 2 * k + 1, l, (l + r) / 2)
        val vr = get(a, b, 2 * k + 2, (l + r) / 2, r)

        return func(vl, vr)
    }

    // 指定要素を取得
    fun getElem(x: Int): Int = segTree[x + size - 1]
}

fun main(args: Array<String>) {
    val mod = 998244353L
    val N = readInputLine().toInt()
    val collisionChain = IntSegmentTree(N, 0, Math::max)
    val robots = Array(N) { readInputLine().split(" ").let { Pair(it[0].toInt(), it[1].toInt()) } }
    robots.sortBy { it.first }

    // ロボットを動かした場合の最大衝突範囲を初期化
    repeat(N) {
        collisionChain.update(it, it)
    }

    // ロボットを動かした場合の最大衝突範囲を二分探索で求めてセグ木に詰める
    for (i in N - 2 downTo 0) {
        val maxCollision = lowerBound(robots, robots[i].first + robots[i].second)
        collisionChain.update(i, collisionChain.get(i, maxCollision))
    }

    // dp[0:動かさない, 1:動かした][Nロボット目でのパターン数(遠くから見る)]
    val dp = Array(2) { LongArray(N) }
    dp[0][N - 1] = 1L
    dp[1][N - 1] = 1L

    for (i in N - 2 downTo 0) {
        dp[0][i] = (dp[0][i + 1] + dp[1][i + 1]) % mod
        val maxCollision = collisionChain.getElem(i)
        if (maxCollision == N - 1) {
            dp[1][i] = 1L
        } else {
            dp[1][i] = (dp[0][maxCollision + 1] + dp[1][maxCollision + 1]) % mod
        }
    }

    println((dp[0][0] + dp[1][0]) % mod)
}

fun readInputLine(): String {
    return readLine()!!
}

fun lowerBound(robots: Array<Pair<Int, Int>>, dist: Int): Int {
    var l = -1
    var r = robots.size

    while (r - l > 1) {
        val mid = (r + l) / 2
        if (robots[mid].first >= dist) {
            r = mid
        } else {
            l = mid
        }
    }

    return r
}
