#include <bits/stdc++.h>
using namespace std;
#define sim template < class c
#define ris return * this
#define dor > debug & operator <<
#define eni(x) sim > typename \
  enable_if<sizeof dud<c>(0) x 1, debug&>::type operator<<(c i) {
sim > struct rge { c b, e; };
sim > rge<c> range(c i, c j) { return rge<c>{i, j}; }
sim > auto dud(c* x) -> decltype(cerr << *x, 0);
sim > char dud(...);
struct debug {
#ifdef LOCAL
~debug() { cerr << endl; }
eni(!=) cerr << boolalpha << i; ris; }
eni(==) ris << range(begin(i), end(i)); }
sim, class b dor(pair < b, c > d) {
  ris << "(" << d.first << ", " << d.second << ")";
}
sim dor(rge<c> d) {
  *this << "[";
  for (auto it = d.b; it != d.e; ++it)
	*this << ", " + 2 * (it == d.b) << *it;
  ris << "]";
}
#else
sim dor(const c&) { ris; }
#endif
};
#define imie(...) " [" << #__VA_ARGS__ ": " << (__VA_ARGS__) << "] "

const int mod = 1e9 + 7;
void add_self(int& a, int b) {
	a += b;
	if(a >= mod) {
		a -= mod;
	}
}

struct Mine {
	long long L, posL, posR, R;
	void read() {
		long long pos, range;
		scanf("%lld%lld", &pos, &range);
		posL = posR = pos;
		L = pos - range;
		R = pos + range;
	}
	// bool hits(const Mine& he) const {
		// if(R < he.posL || he.posR < L) {
			// return false;
		// }
		// return true;
	// }
	void combineWith(const Mine& he) {
		L = min(L, he.L);
		posL = min(posL, he.posL);
		R = max(R, he.R);
		posR = max(posR, he.posR);
	}
	bool contains(const Mine& he) const {
		return posL < he.posL && he.posR < posR;
	}
	bool hits(const Mine& he) const {
		if(he.contains(*this)) {
			return false;
		}
		if(R < he.posL || he.posR < L) {
			return false;
		}
		return true;
	}
};
debug & operator << (debug & dd, Mine mine) { dd << "(" << mine.L << ", " << mine.posL << ", " << mine.posR << ", " << mine.R << ")"; return dd; }

// struct Node {
	// long long big;
// }

int main() {
	int n;
	scanf("%d", &n);
	vector<Mine> offline(n);
	vector<long long> values;
	for(int i = 0; i < n; ++i) {
		offline[i].read();
		values.push_back(offline[i].posL);
		values.push_back(offline[i].R);
		values.push_back(offline[i].L);
	}
	sort(values.begin(), values.end());
	values.resize( unique(values.begin(), values.end()) - values.begin() );
	int k = values.size();
	
	auto get_id = [&](long long x) {
		auto it = lower_bound(values.begin(), values.end(), x);
		assert(it != values.end() && *it == x);
		return it - values.begin();
	};
	vector<vector<Mine>> there(k);
	int base = 1;
	while(base <= k) {
		base *= 2;
	}
	vector<pair<long long, int>> tree(2 * base, make_pair(LONG_LONG_MIN, -1));
	
	auto update_leaf = [&](int j) {
		tree[base+j] = (there[j].empty() ? make_pair(LONG_LONG_MIN, -1) : make_pair(there[j].back().posR, j));
		for(int x = (base + j) / 2; x >= 1; x /= 2) {
			tree[x] = max(tree[2*x], tree[2*x+1]);
		}
	};
	
	vector<Mine> skipped;
	// vector<Mine> mines;
	for(int i = 0; i < n; ++i) {
		Mine nowe = offline[i];
		long long memo_L = nowe.L;
		while(true) {
			pair<long long, int> best{LONG_LONG_MIN, -1};
			auto consider = [&](int id) {
				best = max(best, tree[id]);
			};
			
			int at_least = base + get_id(nowe.posL);
			consider(at_least);
			while(at_least > 1) {
				if(at_least % 2 == 0) {
					consider(at_least + 1);
				}
				at_least /= 2;
			}
			
			/*for(int j = at_least; j < k; ++j) {
				if(!there[j].empty()) {
					best = max(best, make_pair(there[j].back().posR, j));
				}
			}*/
			
			/*for(int j = 0; j < (int) mines.size(); ++j) {
				Mine he = mines[j];
				if(he.R >= nowe.posL) {
					best = max(best, make_pair(he.posR, j));
				}
			}*/
			if(best.first < memo_L) {
				break;
			}
			int j = best.second;
			// mines[j]
			Mine he = there[j].back();
			
			there[j].pop_back();
			update_leaf(j);
			
			if(he.posL >= nowe.posL) {
				skipped.push_back(he);
			}
			else {
				nowe.combineWith(he);
			}
		}
		int id = get_id(nowe.R);
		there[id].push_back(nowe);
		update_leaf(id);
	}
	vector<Mine> mines = skipped;
	for(const vector<Mine>& they : there) {
		mines.insert(mines.end(), they.begin(), they.end());
	}
	sort(mines.begin(), mines.end(), [&](const Mine& a, const Mine& b) {
		return a.posR < b.posR;
	});
	cerr << "new size = " << mines.size() << endl;
	// return 0;
	/*	
					
		for(int j = (int) mines.size() - 1; j >= 0; --j) {
			if(nowe.posL <= mines[j].R && memo_L <= mines[j].posR) { 
				if(skip.count(mines[j].posL)) {
					continue;
				}
				if(mines[j].posL >= nowe.posL) {
					skip.insert(mines[j].posL);
					continue;
				}
				nowe.combineWith(mines[j]);
				mines.erase(mines.begin() + j);
			}
		}
		mines.push_back(nowe);
		// debug() << imie(mines.size());
		debug() << imie(mines);
	}*/
	n = mines.size();
	// sorted by posR
	
	vector<pair<int,int>> intervals(n);
	// vector<pair<long long, int>> his_reach(n);
	
	#define tree tree2
	vector<int> tree(2 * base);
	for(int i = n - 1; i >= 0; --i) {
		int R = i;
		const long long my_reach = mines[i].R;
		auto consider = [&](int id) {
			R = max(R, tree[id]);
		};
		int low = base + get_id(mines[i].posL) + 1;
		int high = base + get_id(my_reach);
		if(low <= high) {
			consider(low);
			consider(high);
			while(low + 1 < high) {
				if(low % 2 == 0) {
					consider(low + 1);
				}
				if(high % 2 == 1) {
					consider(high - 1);
				}
				low /= 2;
				high /= 2;
			}
		}
		/*		
		for(int j = i + 1; j < n; ++j) {
			if(mines[i].posL < mines[j].posL && mines[j].posL <= my_reach) {
				R = max(R, intervals[j].second);
				// reach = max(reach, mines[j].R);
			}
		}*/
		intervals[i].second = R;
		int id = get_id(mines[i].posL);
		for(int x = base + id; x >= 1; x /= 2) {
			tree[x] = max(tree[x], R);
		}
	}
	
	tree = vector<int>(2 * base, INT_MAX);
	for(int i = 0; i < n; ++i) {
		int L = i; //, R = i;
		/*long long reach = mines[i].R;
		for(int j = i + 1; j < n; ++j) {
			if(reach >= mines[j].posL && mines[i].posL < mines[j].posL) {
				R = j;
				reach = max(reach, mines[j].R);
			}
		}*/
		auto consider = [&](int id) {
			L = min(L, tree[id]);
		};
		long long my_reach = mines[i].L;
		int low = base + get_id(my_reach);
		int high = base + get_id(mines[i].posR) - 1;
		if(low <= high) {
			consider(low);
			consider(high);
			while(low + 1 < high) {
				if(low % 2 == 0) {
					consider(low + 1);
				}
				if(high % 2 == 1) {
					consider(high - 1);
				}
				low /= 2;
				high /= 2;
			}
		}
		/*for(int j = i - 1; j >= 0; --j) {
			if(reach <= mines[j].posR && mines[j].posR < mines[i].posR) {
				L = j;
				reach = min(reach, mines[j].L);
			}
		}*/
		intervals[i].first = L;
		int id = get_id(mines[i].posR);
		for(int x = base + id; x >= 1; x /= 2) {
			tree[x] = min(tree[x], L);
		}
	}
	
	// sort(intervals.begin(), intervals.end());
	// intervals.resize( unique(intervals.begin(), intervals.end()) - intervals.begin() );
	
	// debug() << imie(intervals);
	
	/*
	vector<int> reach(n, -1);
	for(pair<int,int> p : intervals) {
		reach[p.first] = max(reach[p.first], p.second);
		// for(int i = p.first; i <= p.second; ++i) {
			// reach[i] = max(reach[i], p.second);
		// }
	}
	debug() << imie(reach);*/
	
	for(pair<int,int>& p : intervals) {
		p.first++;
		p.second++;
		p.second *= -1;
	}
	sort(intervals.begin(), intervals.end());
	vector<int> dp(n + 1);
	// dp[0] = 1;
	
	tree = vector<int>(2 * base);
	auto add = [&](int i, int value) {
		add_self(dp[i], value);
		for(int x = base + i; x >= 1; x /= 2) {
			add_self(tree[x], value);
		}
	};
	add(0, 1);
	// debug() << imie(intervals);
	for(pair<int,int> p : intervals) {
		p.second *= -1;
		int added = 0;
		int i = base + p.second;
		while(i > 1) {
			if(i % 2 == 1) {
				add_self(added, tree[i-1]);
			}
			i /= 2;
		}
		/*for(int i = 0; i < p.second; ++i) {
			add_self(dp[p.second], dp[i]);
			// dp[p.second] += dp[i];
		}*/
		add(p.second, added);
	}
	int answer = 0;
	for(int x : dp) {
		add_self(answer, x);
		// answer += x;
	}
	printf("%d\n", answer);
	
	/*
	// set<set<int>> all;
	int answer = 0;
	for(int mask = 0; mask < (1 << n); ++mask) {
		bool ok = true;
		auto contains = [&](pair<int,int> a, pair<int,int> b) {
			return a.first <= b.first && b.second <= a.second;
		};
		for(int a = 0; a < n; ++a) {
			if(mask & (1 << a)) {
				for(int b = a + 1; b < n; ++b) {
					if(mask & (1 << b)) {
						if(contains(intervals[a], intervals[b]) || contains(intervals[b], intervals[a])) {
							ok = false;
						}
					}
				}
			}
		}
		answer += ok;
		
		// set<int> s;
		// for(int who = 0; who < n; ++who) {
			// if(mask & (1 << who)) {
				// for(int i = intervals[who].first; i <= intervals[who].second; ++i) {
					// s.insert(i);
				// }
			// }
		// }
		// all.insert(s);
		
		// if(s.size() == __builtin_popcount(mask) && !all.count(s)) {
			// all.insert(s);
			// debug() << imie(mask) imie(s);
		// }
	}
	// printf("%d\n", (int) all.size());
	printf("%d\n", answer);*/
	
}