#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using Vi = vector<int>;
using Vl = vector<ll>;
using Pii = pair<int, int>;
using Pll = pair<ll, ll>;

constexpr int I_INF = numeric_limits<int>::max();
constexpr ll L_INF = numeric_limits<ll>::max();

//==================================

template <class T, class Op>
class SegmentTree {
private:
    const Op op;
    const T ID;
    std::vector<T> vec;
    int sz;

public:
    explicit SegmentTree(int _n, Op _op, T _identity) noexcept
        : op(_op), ID(_identity) {
        sz = 1;
        while (sz < _n) sz <<= 1;
        vec.resize(sz * 2, ID);
    }
    explicit SegmentTree(const std::vector<T>& _vec, Op _op, T _identity) noexcept
        : op(_op), ID(_identity) {
        int n = _vec.size();
        sz = 1;
        while (sz < n) sz <<= 1;
        vec.resize(sz * 2, ID);
        set_array(_vec);
    }
    void set_value(int _idx, T _val) noexcept {
        vec[_idx + sz] = _val;
    }
    template <class RandomIt>
    void set_array(RandomIt _begin, RandomIt _end) noexcept {
        std::copy(_begin, _end, vec.begin() + sz);
    }
    void set_array(const std::vector<T>& _newvec) noexcept {
        set_array(_newvec.begin(), _newvec.end());
    }
    void build() noexcept {
        for (int i = sz - 1; i > 0; i--) {
            vec[i] = op(vec[i * 2], vec[i * 2 + 1]);
        }
    }
    void update(int _idx, T _val) noexcept {
        _idx += sz;
        vec[_idx] = _val;
        for (_idx >>= 1; _idx > 0; _idx >>= 1) {
            vec[_idx] = op(vec[_idx * 2], vec[_idx * 2 + 1]);
        }
    }
    T query(int _l, int _r) const noexcept {
        T l_val = ID, r_val = ID;
        _l += sz, _r += sz - 1;
        for (; _l <= _r; _l >>= 1, _r >>= 1) {
            if (_l & 1) l_val = op(l_val, vec[_l++]);
            if (!(_r & 1)) r_val = op(r_val, vec[_r--]);
        }
        return op(l_val, r_val);
    }
    const T& operator[](int _idx) const noexcept {
        return vec[_idx + sz];
    }
};

template <std::int_fast64_t Modulus>
class ModInt {
    using i64 = std::int_fast64_t;

    // friend
    template <std::int_fast64_t _MOD>
    friend std::istream& operator>>(std::istream& is, ModInt<_MOD>& rhs);
    template <std::int_fast64_t _MOD>
    friend std::ostream& operator<<(std::ostream& os, const ModInt<_MOD>& rhs);

private:
    i64 m_value;

public:
    /**
     * コンストラクタ
     */
    constexpr ModInt(const i64 x = 0) noexcept : m_value(x % Modulus) {
        if (m_value < 0) m_value += Modulus;
    }

    constexpr const i64& value() const noexcept { return m_value; }

    constexpr ModInt operator+(const ModInt& rhs) const noexcept {
        return ModInt(*this) += rhs;
    }
    constexpr ModInt operator-(const ModInt& rhs) const noexcept {
        return ModInt(*this) -= rhs;
    }
    constexpr ModInt operator*(const ModInt& rhs) const noexcept {
        return ModInt(*this) *= rhs;
    }
    constexpr ModInt operator/(const ModInt& rhs) const noexcept {
        return ModInt(*this) /= rhs;
    }

    constexpr ModInt& operator+=(const ModInt rhs) noexcept {
        m_value += rhs.m_value;
        if (m_value >= Modulus) {
            m_value -= Modulus;
        }
        return *this;
    }
    constexpr ModInt& operator-=(const ModInt rhs) noexcept {
        if (m_value < rhs.m_value) {
            m_value += Modulus;
        }
        m_value -= rhs.m_value;
        return *this;
    }
    constexpr ModInt& operator*=(const ModInt rhs) noexcept {
        m_value = m_value * rhs.m_value % Modulus;
        return *this;
    }
    constexpr ModInt& operator/=(ModInt rhs) noexcept {
        i64 exp = Modulus - 2;
        while (exp) {
            if (exp & 1) {
                *this *= rhs;
            }
            rhs *= rhs;
            exp >>= 1;
        }
        return *this;
    }

    constexpr ModInt& operator++() noexcept {
        *this += 1;
        return *this;
    }
    constexpr ModInt operator++(int) noexcept {
        ModInt res = *this;
        *this += 1;
        return res;
    }
    constexpr ModInt& operator--() noexcept {
        *this -= 1;
        return *this;
    }
    constexpr ModInt operator--(int) noexcept {
        ModInt res = *this;
        *this -= 1;
        return res;
    }

    constexpr bool operator<(const ModInt& rhs) const noexcept {
        return m_value < rhs.m_value;
    }
    constexpr bool operator>(const ModInt& rhs) const noexcept {
        return m_value > rhs.m_value;
    }
    constexpr bool operator<=(const ModInt& rhs) const noexcept {
        return m_value <= rhs.m_value;
    }
    constexpr bool operator>=(const ModInt& rhs) const noexcept {
        return m_value >= rhs.m_value;
    }
    constexpr bool operator==(const ModInt& rhs) const noexcept {
        return m_value == rhs.m_value;
    }

    constexpr ModInt pow(i64 k) const noexcept {
        ModInt res = 1;
        ModInt tmp = *this;
        for (; k > 0; k >>= 1) {
            if (k & 1) res *= tmp;
            tmp *= tmp;
        }
        return res;
    }

    constexpr ModInt inverse() const noexcept {
        i64 q = m_value;
        i64 b = Modulus, u = 1, v = 0;
        while (b) {
            i64 t = q / b;
            q -= t * b;
            swap(q, b);
            u -= t * v;
            swap(u, v);
        }
        u %= Modulus;
        if (u < 0) u += Modulus;
        return u;
    }
};

// iostream用の関数[ModInt]
template <std::int_fast64_t Modulus>
std::istream& operator>>(std::istream& is, ModInt<Modulus>& rhs) {
    is >> rhs.m_value;
    return is;
}
template <std::int_fast64_t Modulus>
std::ostream& operator<<(std::ostream& os, const ModInt<Modulus>& rhs) {
    os << rhs.m_value;
    return os;
}

constexpr ll MOD = 998244353;
ModInt<MOD> dp[200010];

int main() {
    cin.tie(0);
    ios::sync_with_stdio(false);

    int N;
    cin >> N;
    vector<Pll> robos(N);
    for (int i = 0; i < N; i++) {
        ll x, d;
        cin >> x >> d;
        robos[i].first = x;
        robos[i].second = d;
    }
    sort(robos.begin(), robos.end());

    Vl X(N);
    for (int i = 0; i < N; i++) {
        X[i] = robos[i].first;
    }

    auto fun = [](ll a, ll b) { return max(a, b); };
    Vl R(N);
    SegmentTree<ll, std::function<ll(ll, ll)>> seg(N, fun, 0LL);
    for (int i = N - 1; i >= 0; i--) {
        int idx = lower_bound(X.begin(), X.end(), robos[i].first + robos[i].second) - X.begin() - 1;
        if (idx == i) {
            R[i] = i;
            seg.update(i, R[i]);
        }
        else {
            R[i] = seg.query(i + 1, idx + 1);
            seg.update(i, R[i]);
        }
    }

    dp[N] = 1;
    for (int i = N - 1; i >= 0; i--) {
        dp[i] = dp[i + 1] + dp[R[i] + 1];
    }

    cout << dp[0] << endl;



    return 0;
}

Measured memory_bytes: 12160