//--------------------------------------------------
//#pragma GCC target("sse,sse2,sse3,ssse3,sse4,abm,mmx,avx,avx2,popcnt,fma")
//#pragma GCC optimize("fast-math")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC optimize("Ofast")
//--------------------------------------------------
#include <bits/stdc++.h>
#include <chrono>
#include <set>
#include <map>
#include <deque>
#include <cmath>
#include <queue>
#include <cassert>
#include <random>
#include <bitset>
#include <iomanip>
#include <numeric>
#include <time.h>
#include <ctime>
#include <string>
#include <cstdio>
#include <vector>
#include <cstdlib>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>
#include <fstream>
#include <stack>
#include <cstring>
//--------------------------------------------------
#define forn(i, n) for(int i = 0; i < n; i++)
#define forw(i, n) for(int i = n-1; i >= 0; --i)
#define forns(i, n, s) for(int i = s; i < n; i++)
#define x first
#define y second
#define pb push_back
#define mp make_pair
#define all(v) v.begin(),v.end()
#define allr(v) v.rbegin(),v.rend()
//----------------------------------------------------
using namespace std;
//----------------------------------------------------
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef long double ld;
typedef vector<ll> lnum;
typedef complex<ld> comp;
//----------------------------------------------------
const ll mod = 1e9 + 7, mod2 = 998244353;
const ld eps = 1e-6;
const ll inf = 1e18;
const int base = 1e9;
const ld PI = 3.1415926;
//----------------------------------------------------
//#define endl '\n';
#ifdef MY_DEBUG
void deb(ld x) { cerr << x << endl; };
#else
void deb(ld x){};
#endif
//----------------------------------------------------
int n;
vector<pair<int, int>> v;
vector<int> r;
ll dp[2*100*1000+1];
int t[4*2*100*1000];
//----------------------------------------------------
unsigned int bitcount(ull val) { return __builtin_popcount(val) + __builtin_popcount(val >> 32); }

void local() {
    freopen("test.in", "r", stdin);
}

void remote() {
}

void read() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    cin >> n;
    v.resize(n);
    forn(i, n){
        int x, d;
        cin >> x >> d;
        v[i] = {x, d};
    }
}

int bs(ll val){
    int l = 0, r = v.size();
    while(r - l > 1){
        int m = (l+r)/2;
        if(v[m].x < val) l = m;
        else r = m;
    }
    return l;
}

void build(int v, int l, int r){
    if(l == r){
        t[v] = l;
    }else{
        int m = (l+r)/2;
        build(v*2, l, m);
        build(v*2+1, m+1, r);
        t[v] = max(t[v*2], t[v*2+1]);
    }
}

int get(int v, int tl, int tr, int l, int r){
    if(l > r)
        return 0;
    if(tl == l && tr == r){
        return t[v];
    }else{
        int m = (tl+tr)/2;
        return max(get(v*2, tl, m, l, min(r, m)),
                get(v*2+1, m+1, tr, max(l, m+1), r));
    }
}

void update(int v, int l, int r, int ind, int val){
    if(l == r)
        t[v] = val;
    else{
        int m = (l+r)/2;
        if(ind <= m) update(v*2, l, m, ind, val);
        else update(v*2+1, m+1, r, ind, val);
        t[v] = max(t[v*2], t[v*2+1]);
    }
}

int main() {
#ifdef MY_DEBUG
    local();
#else
    remote();
#endif
    read();

    //для каждого чела посчитаем кого он затрагивает если активируется
    sort(all(v));
    r.resize(n);
    build(1, 0, n-1);
    forw(i, n){
        int rr = bs(v[i].x * 1ll + v[i].y);
        int mx = get(1, 0, n-1, i, rr);
        r[i] = max(i, mx);
        update(1, 0, n-1, i, r[i]);
    }

    // а теперь можно посчитать простое дп, где dp[i] - сколько возможных подмножеств, если мы
    // рассматриваем робота i и всех тех, кто после него
    // пусть i не активирован, тогда подойдут все подмножества с i+1 робота
    // пусть i - активироваг, тогда подойдут все подможества с r[i]+1 робота
    dp[n] = 1;
    forw(i, n){
        dp[i] = (dp[i+1] + dp[r[i]+1]) % mod2;
    }

    cout << dp[0] << endl;

}

Measured memory_bytes: 7296