#include <ctime>
#include <cassert>
#include <iostream>
#include <iomanip>
#include <vector>
#include <deque>
#include <algorithm>
#include <map>
using namespace std;
const int MAXN = 500000;
const long long MOD = 1000000007;

#define FOR(i, n) for(int i = 0, __n = (n); i < __n; i++)

long long x[MAXN];
int a[MAXN];
int b[MAXN];
int ap[MAXN];
int bp[MAXN];
int id[MAXN];
int idweight[MAXN];
long long r[MAXN];
long long P[MAXN+1];
typedef pair<int, int> para;
int deg[MAXN];

vector<int> L[MAXN];


int getid(int i) {
  if (i == -1) return -1;
  if (id[i] == i) return i;
  else return id[i] = getid(id[i]);
}

int mergeid(int i, int j) {
  // cerr << "Merge " << i << " "<< j << endl;
  i = getid(i);
  j = getid(j);
  if(i == j) return i;
  if (idweight[i] < idweight[j]) swap(i, j);
  idweight[i] += idweight[j] + 1;
  return id[j] = i;
}



struct Tree {
  vector<vector<long long> > V;
  void init(int size) {
    V.push_back(vector<long long>());
    V.back().resize(size);
    if (size > 1) init(size >> 1);
  }

  // suma przed pos
  long long sum(int pos, int lvl = 0) {
    
    // cerr << "SUM " << pos << "/" << lvl << endl;
    // assert(lvl < V.size());
    // assert(pos <= V[lvl].size());
    if (pos == 0 || lvl >= V.size()) return 0;
    long long total = (pos & 1) ? V[lvl][pos-1] : 0;
    total += sum(pos >> 1, lvl + 1);
    return total % MOD;
  }

  void add(int pos, long long val, int lvl = 0) {
    if (lvl >= V.size() || pos >= V[lvl].size()) return;
    // cerr << "ADD " << pos << "/" << lvl << " = " << val << " >> " << V.size() << endl;
    add(pos >> 1, val, lvl+1);
    V[lvl][pos] += val;
    V[lvl][pos] %= MOD;
  }
};

bool sorter(const para&p, const para&q) {
  if(p.first != q.first) return p.first < q.first;
  return p.second > q.second;
}

int main() {
  ios_base::sync_with_stdio(0);
  int n;
  cin >> n;
  FOR(i, n) {
    cin >> x[i] >> r[i];
  }
  FOR(i, n) id[i] = i;

  vector<int> S;

  FOR(i, n) {
    a[i] = lower_bound(x, x+i, x[i]-r[i]) - x;
    b[i] = upper_bound(x+1, x+n, x[i] + r[i]) - x - 1;
  }

  FOR(i, n) {
    while(!S.empty() && b[S.back()] < i) {
      S.pop_back();
    }
    ap[i] = S.empty() ? -1 : S.back();
    while(!S.empty() && b[S.back()] <= b[i]) {
      S.pop_back();
    }
    S.push_back(i);
  }
  S.clear();
  for (int i = n-1; i >= 0; i--) {
    while(!S.empty() && a[S.back()] > i) {
      S.pop_back();
    }
    bp[i] = S.empty() ? -1 : S.back();
    while(!S.empty() && a[S.back()] >= a[i]) {
      S.pop_back();
    }
    S.push_back(i);
  }
  S.clear();

  // FOR(i, n) {
  //   cerr << "> " << i << " " << x[i] << "-" << r[i] << " "<< id[i] << " :: " << a[i] << " " << b[i] <<  " :: " << ap[i] << " " << bp[i] << endl;
  // }
  
  // int idx = 0;
  FOR(ig, n) {
    int k = getid(ig);
    while (1) {
      // cerr << ig << endl;
  // FOR(i, n) {
  //   cerr << "> " << i << " " << x[i] << "-" << r[i] << " "<< id[i] << " :: " << a[i] << " " << b[i] <<  " :: " << ap[i] << " " << bp[i] << endl;
  // }
      int i = -1, j = -1;
      if(getid(bp[k]) != -1 && getid(ap[getid(bp[k])]) == k) {
        i = k;
        j = getid(bp[k]);
      }
      if(getid(ap[k]) != -1 && getid(bp[getid(ap[k])]) == k) {
        i = getid(ap[k]);
        j = k;
      }
      if(i == -1) break;

      bp[i] = bp[j];
      ap[j] = ap[i];
      a[i] = a[j] = min(a[i], a[j]);
      b[i] = b[j] = max(b[i], b[j]);

      k = mergeid(i, j);
    }
  }

  FOR(i, n) if(getid(i) != i) {
    int j = getid(i);
    a[j] = min(a[j], a[i]);
    b[j] = max(b[j], b[i]);
  }


  // FOR(i, n) {
  //   cerr << "> " << i << " " << x[i] << "-" << r[i] << " "<< id[i] << " :: " << a[i] << " " << b[i] <<  " :: " << ap[i] << " " << bp[i] << endl;
  // }

  FOR (i, n) {
    // cerr << "> " << i << " " << id[i] << " :: " << a[i] << " " << b[i] <<  " :: " << ap[i] << " " << bp[i] << endl;
    if(ap[i] != -1 && getid(ap[i]) != getid(i)) {
      L[getid(i)].push_back(getid(ap[i]));
      deg[getid(ap[i])]++;
      // cerr << getid(i) << "->" << getid(ap[i]) << endl;
      // V.push_back(para(getid(ap[i]), getid(i)));
    }
    if(bp[i] != -1 && getid(bp[i]) != getid(i)) {
      L[getid(i)].push_back(getid(bp[i]));
      deg[getid(bp[i])]++;
      // cerr << getid(i) << "->" << getid(bp[i]) << endl;
      // V.push_back(para(getid(bp[i]), getid(i)));
    }
  }

  FOR(i, n) if (getid(i) == i) {
    if(deg[i] == 0) {
      S.push_back(i);
    }
  } else {
    int idx = getid(i);
    // a[idx] = min(a[idx], a[i]);
    // b[idx] = max(b[idx], b[i]);
  }
  for (int idx = 0; idx<S.size(); idx++) {
    int i = S[idx];
    FOR(jdx, L[i].size()) {
      int j = L[i][jdx];
      deg[j]--;
      if(deg[j] == 0) {
        S.push_back(j);
      }
    }
  }
  FOR(idx, S.size()) {
    // cerr << "}" << S[idx] << endl;
    int i = S[idx];

    FOR(jdx, L[i].size()) {
      int j = L[i][jdx];
      a[j] = min(a[j], a[i]);
      b[j] = max(b[j], b[i]);
    }
  }

  // FOR (i, n) if (getid(i) == i) {
  //   cerr << "> " << i << " " << id[i] << " :: " << a[i] << " " << b[i] <<  " :: " << ap[i] << " " << bp[i] << endl;
  // }


  vector<pair<int, int> > V;
  FOR(i, n) if(i == getid(i)) {
    V.push_back(pair<int, int>(a[i]+1, b[i]+1));
  }
  sort(V.begin(), V.end(), sorter);
  // V.resize(unique(V.begin(), V.end()) - V.begin());
  FOR(i, V.size()) {
    a[i] = V[i].first;
    b[i] = V[i].second;
  }
  int maxB = n+1;
  // FOR(i, V.size()) {
  //   cerr << a[i] << " <> " << b[i] << endl;
  // }
  Tree T;
  T.init(maxB);
  T.add(0, 1);
  long long total = 1;
  int head = 0;
  FOR(i, V.size()) {
    long long sum = T.sum(b[i]);
    P[i] = sum;
    // assert(sum < MOD && sum >= 0);
    T.add(b[i], sum);
    total = (total + sum) %MOD;
  }
  cout << total << endl;


  return 0;
}