#include <bits/stdc++.h>


using namespace std;



// sprawdź stałą!!!
const long long M = 1000000007;

long long n;

long long a[350000], r[350000];

long long dp_zab[350000];
long long dp_zost[350000];
long long dp_total[350000];
long long pref_sum[350000];

class ordering{
	public:
		bool high;
		vector < pair < long long, long long > > v;
		vector < long long> v_min;
		bool comp(long long x, long long y){
			if((x > y and high) or (x < y and !high)){
				return true;
			}
			return false;
		}
		long long mini(long long x, long long y){
			if(comp(x, y)){
				//cout << "T" << x << endl;
				return x;
			}
			return y;
		}

		void insert(long long ind, long long val){
			//cout << "insert: " << ind << " " << val << endl;
			if(v.size() > 0){
				if(high){
					while(!v_min.empty()){
						if(val <= v_min[v_min.size() - 1]){
							v_min.pop_back();
							v.pop_back();
						}
						else{
							break;
						}
					}
					v_min.push_back(val);
					v.push_back(make_pair(ind, val));
				}
				else{
					while(!v_min.empty()){
						if(val >= v_min[v_min.size() - 1]){
							v_min.pop_back();
							v.pop_back();
						}
						else{
							break;
						}
					}
					v_min.push_back(val);
					v.push_back(make_pair(ind, val));
				}
			}
			else{
				v_min.push_back(val);
				v.push_back(make_pair(ind, val));
			}
			
			
		}

		

		// zwraca największy ind, że val
		long long bound(long long val){

			// binsearch
			long long maksimum = v_min.size() - 1;
			long long minimum = -1;
			long long cur;
			if(high){
				while(maksimum > minimum){
					//cout << "A" << endl;
					cur = minimum + (maksimum - minimum + 1) / 2;
					//cout << "maksimum = " << maksimum << " cur = " << cur << " minimum = " << minimum << endl;
					if(val > v_min[cur]){
						minimum = cur;
					}
					else{
						maksimum = cur - 1;
					}
				}
			}
			else{
				while(maksimum > minimum){
					//cout << "B" << endl;
					cur = minimum + (maksimum - minimum +1) / 2;
					//cout << "maksimum = " << maksimum << " cur = " << cur << " minimum = " << minimum << endl;
					if(val < v_min[cur]){
						minimum = cur;
					}
					else{
						maksimum = cur - 1;
					}
				}
			}
			
			
			
			/*cout << "val =  " << val << endl;
			cout << "high = " << high << endl;
			for (long long i = 0; i < v.size(); ++i)
			{
				cout << v[i].second << "(" << v[i].first<< ") ";
			}
			cout << endl;

			cout << "m = " << m << " maksimum = " << maksimum << endl << endl;
			
			return m;*/
			if(maksimum == -1)	return -1;
			/*if(v[maksimum].first == 0){
				return -1;
			}*/
			return v[maksimum].first;
		}
};


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

	cin >> n;
	for (long long i = 1; i <= n; ++i)
	{
		cin >> a[i] >> r[i];
	}

	// to trzeba sprawdzić
	dp_zost[1] = 1;
	dp_zab[1] = 1;
	dp_total[1] = 2;

	// orderingi
	ordering a_ord;
	ordering a_diff_ord;
	ordering a_sum_ord;

	a_ord.insert(1, a[1] % M);
	a_ord.high = true;
	a_diff_ord.insert(1, (a[1] - r[1] - 1) );
	a_diff_ord.high = true;
	a_sum_ord.insert(1, (a[1] + r[1] + 1));
	a_sum_ord.high = false;

	stack < long long > white_alive;
	set < pair < long long, long long > > white_alive_set;
	white_alive.push(1);
	pref_sum[1] = dp_zost[1] % M;
	white_alive_set.insert(make_pair(1, 0));

	for (long long i = 2; i <= n; ++i)
	{

		// najpierw i-ty żyje

		long long zost_j = a_sum_ord.bound(a[i]);
		if(zost_j == -1){
			dp_zost[i]++;
		}	

		//cout << zost_j << endl;
		long long c = 0;

		pair < long long, long long > t1 = *(white_alive_set.upper_bound(make_pair(zost_j, -2)));

		dp_zost[i] += (pref_sum[white_alive.size()] - pref_sum[t1.second] + M ) % M;



		// teraz i-ty nie żyje

		long long first_j = a_ord.bound(a[i] - r[i]);
		long long second_j = a_diff_ord.bound(a[i] - r[i]);

		if(first_j == second_j and second_j == -1){
			dp_zab[i] = 1;
		}
		else{
			if(second_j > first_j){
				dp_zab[i] = dp_zab[second_j];
			}
			else{
				if(first_j == i - 1){
					dp_zab[i] = dp_total[first_j];
				}
				dp_zab[i] = dp_total[first_j];
			}
		}


		
		dp_total[i] = (dp_zab[i] + dp_zost[i]) % M;
		a_ord.insert(i, a[i]);
		a_diff_ord.insert(i, a[i] - r[i] - 1);
		a_sum_ord.insert(i, a[i] + r[i] + 1);

		// aktualizujemy white_alive
		while(!white_alive.empty()){
			if(a[white_alive.top()] >= a[i] - r[i]){
				//cout << "A" << endl;
				white_alive_set.erase(white_alive_set.find(make_pair(white_alive.top(), white_alive.size() - 1)));

				//cout << "B" << endl;
				pref_sum[white_alive.size()] = 0;
				white_alive.pop();
			}
			else{
				break;
			}
			//cout << "A" << endl;
		}
		white_alive_set.insert(make_pair(i, white_alive.size()));
		white_alive.push(i);
		pref_sum[white_alive.size()] = (pref_sum[white_alive.size() - 1] + dp_zost[i])%M;
		//cout << "size = " << white_alive.size() << endl;
		//cout << dp_zab[i] << " " << dp_zost[i] << endl;
	}

	//cout << dp_zab[n] << " ";

	cout << (dp_zab[n] + dp_zost[n] + M) % M << endl;
}