#include<iostream>
#include<vector>
#include<algorithm>
#include<deque>
using namespace std;
 
class ModInt{
private:
  long long val;
  static const int default_mod = 1e9 + 7;
  static int mod;
  static vector<ModInt> facts;
public:
  ModInt(long long val)
  {
    if(mod == 0){
      mod = default_mod;
    }
    this->val = ((val % mod) + mod) % mod;
  }
  ModInt()
    : ModInt(0)
  {
  }
  static void setMod(int mod){
    if(ModInt::mod != 0){
      throw "The modulo is already set.";
    }
    ModInt::mod = mod;
  }

  const ModInt operator* (const ModInt& another) const{
    return ModInt(val * another.val);
  }
  ModInt operator+ (const ModInt& another){
    return ModInt(val + another.val);
  }
  ModInt operator- (const ModInt & another){
    return ModInt(val - another.val + mod);
  }
  ModInt operator/(const ModInt& rhs){
    return (*this) * rhs.inv();
  }
  ModInt& operator*=(const ModInt& rhs){
    (*this) = (*this) * rhs;
    return *this;
  }
  ModInt& operator+=(const ModInt& rhs){
    (*this) = (*this) + rhs;
    return *this;
  }
  ModInt& operator-=(const ModInt& rhs){
    (*this) = (*this) - rhs;
    return *this;
  }
  ModInt& operator/=(const ModInt& rhs){
    (*this) = (*this) / rhs;
    return *this;
  }
  ModInt pow(long long exponent) const{
    exponent %= mod - 1;
    if(exponent == 0){
      return ModInt(1);
    }else{
      if(exponent % 2){
        return ((*this) * (*this)).pow(exponent / 2) * (*this);
      }else{
        return ((*this) * (*this)).pow(exponent / 2);
      }
    }
  }
  ModInt inv() const{
    return this->pow(mod - 2);
  }
  static ModInt fact(long long n){
    if(n >= mod){
      return 0;
    }
    if(facts.size() < static_cast<size_t>(n + 1)){
      if(facts.size() == 0){
        facts.push_back(1);
      }
      for(int i = facts.size(); i <= n; i++){
        facts.push_back(facts[i - 1] * i);
      }
    }
    return facts[n];
  }
  static ModInt comb(long long n, long long r){
    if(r > n){
      return 0;
    }
    return ModInt::fact(n) * ModInt::fact(r).inv() * ModInt::fact(n - r).inv();
  }
 
  friend ostream& operator<< (ostream& os, const ModInt& modint){
    os << modint.val;
    return os;
  }
  friend istream& operator>>(istream& is, ModInt& modint){
    long long val;
    is >> val;
    modint.val = val % modint.mod;
    return is;
  }
  friend ModInt operator*(const long long lhs, const ModInt& rhs){
    return ModInt(lhs) * rhs;
  }
};
int ModInt::mod = 0;
vector<ModInt> ModInt::facts;


int main(){
  ModInt::setMod(998244353);

  int N;
  cin >> N;

  vector<pair<int, int>> XD(N);
  for(int i = 0; i < N; i++){
    int x, d;
    cin >> x >> d;
    XD[i] = make_pair(x, d);
  }
  sort(XD.begin(), XD.end());

  deque<pair<int, int>> vanish;
  vector<ModInt> dp_sur(N), dp_van(N);
  vanish.push_back(make_pair(XD[N - 1].first, N - 1));
  dp_sur[N - 1] = 1, dp_van[N - 1] = 1;
  for(int i = N - 2; i >= 0; i--){
    dp_sur[i] = dp_sur[i + 1] + dp_van[i + 1];

    // not vanish
    auto itr = lower_bound(vanish.begin(), vanish.end(), make_pair(XD[i].first + XD[i].second, 0));
    if(itr == vanish.end()){
      dp_van[i] = 1;
      vanish.clear();
      vanish.push_back(make_pair(XD[i].first, N - 1));
    }else if(itr == vanish.begin()){
      dp_van[i] = dp_sur[i + 1] + dp_van[i + 1];
      vanish.push_front(make_pair(XD[i].first, i));
    }else{
      itr--;
      int vanish_idx = itr -> second;
      dp_van[i] = dp_van[vanish_idx];
      while(vanish.front().second != vanish_idx){
        vanish.pop_front();
      }
      vanish.pop_front();
      vanish.push_front(make_pair(XD[i].first, vanish_idx));
    }

    //cout << dp_sur[i] << ' ' << dp_van[i] << endl;
  }
  cout << dp_sur[0] + dp_van[0] << endl;
}



Measured memory_bytes: 5760