#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a),end(a)
#define FOR(x,val,to) for(int x=(val);x<int((to));++x)
#define FORE(x,val,to) for(auto x=(val);x<=(to);++x)
#define FORR(x,arr) for(auto &x: arr)
#define FORS(x,plus,arr) for(auto x = begin(arr)+(plus); x != end(arr); ++x)
#define FORREV(x,plus,arr) for(auto x = (arr).rbegin()+(plus); x !=(arr).rend(); ++x)
#define REE(s_) {cout<<s_<<'\n';exit(0);}
#define GET(arr) for(auto &i: (arr)) sc(i)
#define whatis(x) cerr << #x << " is " << (x) << endl;
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
typedef std::pair<int,int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef uint64_t ull;
#define umap unordered_map
#define uset unordered_set
using namespace std;
using namespace __gnu_pbds;

#ifdef ONLINE_JUDGE
#define whatis(x) ;
#endif
#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template<class L, class R> ostream& operator<<(ostream &os, map<L, R> P) { for(auto const &vv: P)os<<"("<<vv.first<<","<<vv.second<<")"; return os; }
template<class T> ostream& operator<<(ostream &os, set<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class T> ostream& operator<<(ostream &os, vector<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class L, class R> ostream& operator<<(ostream &os, pair<L, R> P) { os<<"("<<P.first<<","<<P.second<<")"; return os; }
inline int fstoi(const string &str){auto it=str.begin();bool neg=0;int num=0;if(*it=='-')neg=1;else num=*it-'0';++it;while(it<str.end()) num=num*10+(*it++-'0');if(neg)num*=-1;return num;}
inline void getch(char &x){while(x = getchar_unlocked(), x < 33){;}}
inline void getstr(string &str){str.clear(); char cur;while(cur=getchar_unlocked(),cur<33){;}while(cur>32){str+=cur;cur=getchar_unlocked();}}
template<typename T> inline bool sc(T &num){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){if(c == EOF) return false;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; return true;}template<typename T, typename ...Args> inline void sc(T &num, Args &...args){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; sc(args...); }
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; //s.find_by_order(), s.order_of_key() <- works like lower_bound
template<typename T> using ordered_map = tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define N 300300

constexpr int64_t mod = 1000000007;

/* vector<int> adj[N]; */
int dfs_num[N], dfs_min[N];
int wh[N];
/* vector<int> adj2[N]; */
vector<vector<int>> scc;
stack<int> st;
int it;
int ll[N], rr[N];

// tarjan with lazy segtree go brrr
// wsm nie potrzebuję lazy, starczy ta modyfikacja iteracyjnego śmieszna, bo
// settuję w punkcie (i w każdym tylko raz)

// wait wtf??????
// przecież to jest zwykłe segtree XDDD
// 05:00 effect much

/* int nn = N; */
// I guess let's decrease that
int nn; // set this
/* int t[N << 2]; */
int t[N << 1];
/* int t2[N << 1]; */
int tmax[N << 1];

int query(int l, int r){
    /* int res = 0; */
    int res = 0x7f7f7f7f;
    for(l+=nn, r+=nn; l<r; l>>=1, r>>=1){
        if(l&1)
            /* res = max(res,t[l++]); */
            res = min(res,t[l++]);
            //res += t[l++];
        if(r&1)
            /* res = max(res,t[--r]); */
            res = min(res,t[--r]);
            //res += t[--r];
    }
    return res;
}

void modify(int p, int val){
    for(t[p += nn] = val; p > 1; p>>=1) // fine, chcę faktycznie settować; nie minować
        /* t[p>>1] = max(t[p] , t[p^1]); */
        t[p>>1] = min(t[p] , t[p^1]);
}

int querymax(int l, int r){
    /* int res = 0; */
    /* int res = 0x7f7f7f7f; */ // yeah forgot to chg that
    int res = 0; // 0 is very fine here for sure
    for(l+=nn, r+=nn; l<r; l>>=1, r>>=1){
        if(l&1)
            /* res = max(res,t[l++]); */
            res = max(res,tmax[l++]);
            //res += t[l++];
        if(r&1)
            /* res = max(res,t[--r]); */
            res = max(res,tmax[--r]);
            //res += t[--r];
    }
    return res;
}

void modifymax(int p, int val){
    for(tmax[p += nn] = val; p > 1; p>>=1) // fine, chcę faktycznie settować; nie minować
        /* t[p>>1] = max(t[p] , t[p^1]); */
        // XDDDDDDDDDDDDDD
        // O(duże) iq nie zmieniając t na prawo
        // rip time
        /* tmax[p>>1] = max(t[p] , t[p^1]); */
        tmax[p>>1] = max(tmax[p] , tmax[p^1]);

}


set<int> unvis; // isn't set too slow technically?

//Order of SCCs is a reverse topological sort of SCC Condensation-DAG
void tarjan(int cur){
    /* whatis(cur) */
    unvis.erase(cur);
    dfs_num[cur] = dfs_min[cur] = ++it;
    /* modify(cur, dfs_min[cur]); */ // starczy niżej
    modify(cur, dfs_min[cur]); // jednak chyba nie
    st.push(cur);
    /* auto it = unvis.lower_bound(ll[cur]); */
    // bugg, but found out quickly
    /* while(it != unvis.end() && *it != rr[cur]) */
    /* whatis(unvis) */
    // wtf, jak ten infinite loop działa?
    // oh wait, nie mam ++ w tej pętli zaraz poniżej lol
    // actually, muszę robić lower_bound co turę, bo mogą być usuwane te
    // wierzchołki i guess
    /* whatis(*it) */
    /* while(it != unvis.end() && *it <= rr[cur]){ */
    /*     tarjan(*it); */
    /* } */
    set<int>::iterator it;
    // safe much
    while(it = unvis.lower_bound(ll[cur]), it != unvis.end() && *it <= rr[cur]){
        tarjan(*it);
    }
    /* for(auto &i: adj[cur]){ */
    /*     if(!dfs_num[i]) */
    /*         tarjan(i); */
    /*     dfs_min[cur] = min(dfs_min[cur], dfs_min[i]); */
    /* } */
    /* dfs_min[cur] = query(ll[cur], rr[cur] + 1); */
    dfs_min[cur] = min(dfs_min[cur],query(ll[cur], rr[cur] + 1));
    /* whatis(cur) */
    /* whatis(dfs_num[cur]) */
    /* whatis(dfs_min[cur]) */
    // kolejnosc obczajania tego dfs_min ma znaczenie?
    // i guess not? bo po visitowaniu nodea, dla niego jest już stałe *chyba że
    // w scc się złoży*?
    modify(cur, dfs_min[cur]);
    if(dfs_num[cur] == dfs_min[cur]){
        scc.push_back({});
        int cr;
        do{
            //elements of the scc
            cr = st.top(); st.pop();
            dfs_min[cr] = 0x7f7f7f7f;
            // it was as this moment, I realized, I want a normal, most
            // standard segtree ever
            modify(cr, dfs_min[cr]);
            wh[cr] = scc.size()-1;
            scc.back().push_back(cr);
        }while(cr != cur);
    }
}

int main(){
    ios_base::sync_with_stdio(0);cin.tie(0);
    memset(t,127,sizeof t);
    int n;
    sc(n);
    nn = n; // important
    pair<int64_t,int64_t> a[n];
    FORR(i,a)
        sc(i.e1,i.e2);
    // liniówka damn
    // or wsm nie do końca, bo lower_bound na poczatku i guess
    /* int ll[n], rr[n]; */
    for(int i = 0; i < n; ++i){
        // rip attempt przez compile error
        ll[i] = lower_bound(a,a+n,mp(a[i].e1 - a[i].e2, (int64_t)0)) - a;
        rr[i] = lower_bound(a,a+n,mp(a[i].e1 + a[i].e2 + 1, (int64_t)0)) - 1 - a; // i in worst case
    }
    // ll / rr mam źle wyliczane na razie
    /* for(int i = 1; i < n; ++i){ */
    /*     // segtree here wsm? */
    /*     /1* for(int x = ll[i]; x < i; ++x) *1/ */
    /*     for(int x = ll[i]; x <= rr[i]; ++x) // still bad, no bo rr[i], jak i ll[x] na prawo są niewyliczone xd */
    /*         ll[i] = min(ll[i], ll[x]); */
    /* } */
    /* for(int i = 0; i < n - 1; ++i){ */
    /*     // segtree here wsm? */
    /*     /1* for(int x = rr[i]; x > i; --x) *1/ */
    /*     for(int x = rr[i]; x >= ll[i]; --x) // still bad */
    /*         rr[i] = max(rr[i], rr[x]); */
    /* } */
    /* set<int> unvis; */
    // XD nice local shaddowing
    FOR(i,0,n)
        unvis.insert(i);
    for(int i = 0; i < n; ++i){
        if(!dfs_num[i]){
            /* whatis(i) */
            tarjan(i);
        }
    }
    /* whatis(scc) */
    // chyba git w końcu z scc <3
    // sort scc by l?
    // by pos wsm
    // reverse wsm nie starczy?
    // idk jak to działa wsm, better sort
    sort(all(scc),[](vi &f, vi &s){return f[0] < s[0];});
    /* whatis(scc) */
    // lazy
    /* FOR(t,0,2){ */
    /*     FORR(i,scc){ */
    /*         int crll = 0x7f7f7f7f; */
    /*         int crrr = 0; */
    /*         FORR(x,i){ */
    /*             crll = min(crll, ll[x]); */
    /*             crrr = max(crrr, rr[x]); */
    /*         } */
    /*         // jeszcze segtree do tego btw */
    /*         for(int x = crll; x <= crrr; ++x) // powinno starczyć do samego krańcowego punkta */
    /*             crll = min(crll, ll[x]); */
    /*         // crrr oddzielnie, po reversie, bo ma być non-inc, tak jak dla crll non-desc */
    /*         // w teorii mogę być lazy, i po prostu 2 razy całość porobić brrr */
    /*         for(int x = crrr; x >= crll; --x) */
    /*             crrr = max(crrr, rr[x]); */
    /*         FORR(x,i){ */
    /*             ll[x] = crll; */
    /*             rr[x] = crrr; */
    /*         } */
    /*     } */
    /*     reverse(all(scc)); */
    /* } */
    // not lazy anymore
    // let's reuse one segtree ez
    memset(t,127,sizeof t);
    // wait, can build liniowo wsm
    /* FOR(i,0,n){ */
    /*     modify(i, ll[i]); */
    /*     modifymax(i, rr[i]); */
    /* } */
    for(int i = n; i < n << 1; ++i){
        t[i] = ll[i-n];
        tmax[i] = rr[i-n];
    }
    for(int i = n-1; i > 0; --i){
        t[i] = min(t[i << 1], t[i << 1 | 1]);
        tmax[i] = max(tmax[i << 1], tmax[i << 1 | 1]);
    }
    FORR(i,scc){
        int crll = 0x7f7f7f7f;
        int crrr = 0;
        FORR(x,i){
            crll = min(crll, ll[x]);
            crrr = max(crrr, rr[x]);
        }
        // pierwsze testy na forum baaardzo słabe, bez żadnego wa jak wywalę te linijki totalnie

        // more segtrees brr
        /* for(int x = crll; x <= crrr; ++x) // powinno starczyć do samego krańcowego punkta */
        /*     crll = min(crll, ll[x]); */
        /* for(int x = crrr; x >= crll; --x) */
        /*     crrr = max(crrr, rr[x]); */
        crll = query(crll, crrr + 1);
        FORR(x,i){
            assert(ll[x] >= crll);
            ll[x] = crll;
            modify(x, crll);
            // wtf, res schodzi poniżej tego jaki ma być
            // lol, przypisywanie niższego niż jest?
            /* rr[x] = crrr; */
            /* modifymax(x, crrr); */
        }
    }
    reverse(all(scc));
    // not ac on first try after chg, rip
    FORR(i,scc){
        int crll = 0x7f7f7f7f;
        int crrr = 0;
        FORR(x,i){
            crll = min(crll, ll[x]);
            crrr = max(crrr, rr[x]);
        }
        /* int crrrorig = crrr; */
        /* int crrr2 = crrr; */
        /* for(int x = crrr; x >= crll; --x) */
        /*     crrr2 = max(crrr2, rr[x]); */
        crrr = querymax(crll, crrr + 1);
        /* whatis(crrr) */
        /* whatis(crrr2) */
        /* if(crrr != crrr2){ */
        /*     for(int x = crrrorig; x >= crll; --x){ */
        /*         whatis(x) */
        /*         whatis(rr[x]) */
        /*         whatis(querymax(x, x+1)) */
        /*         // wtf, to samo */
        /*     } */
        /*     /1* whatis(querymax(crll, crrrorig + 1)) *1/ */
        /*     /1* whatis(querymax(crll, crrrorig)) *1/ */
        /*     /1* whatis(querymax(crll, crrrorig - 1)) *1/ */
        /*     /1* whatis(querymax(crll, crrrorig - 1)) *1/ */
        /*     /1* whatis(querymax(crll, crll + 1)) *1/ */
        /*     /1* whatis(querymax(crrrorig, crrrorig + 1)) // 4 *1/ */
        /*     /1* whatis(querymax(crrrorig - 1, crrrorig + 1)) // 2 -> hmm *1/ */
        /*     // ?? x, x + 1 -> 4; crll, crll + 1 -> 2 nvm, nie ten koniec */
        /*     /1* whatis(crll) *1/ */
        /*     /1* whatis(crll + 1) *1/ */
        /* } */
        // -> wtf, miałem t[i] w modifymax
        /* crrr = max(crrr,querymax(crll, crrr + 1)); */
        FORR(x,i){
            // assert failed
            // wait, nvm, porównywałem z crll zamiast z crrr
            /* assert(rr[x] <= crll); */
            // -> sth with segtrees bad, bo pętle działają
            assert(rr[x] <= crrr);
            rr[x] = crrr;
            modifymax(x, crrr);
        }
    }
    /* FOR(t,0,2){ */
    /*     FORR(i,scc){ */
    /*         int crll = 0x7f7f7f7f; */
    /*         int crrr = 0; */
    /*         FORR(x,i){ */
    /*             crll = min(crll, ll[x]); */
    /*             crrr = max(crrr, rr[x]); */
    /*         } */
    /*         // jeszcze segtree do tego btw */
    /*         for(int x = crll; x <= crrr; ++x) // powinno starczyć do samego krańcowego punkta */
    /*             crll = min(crll, ll[x]); */
    /*         // crrr oddzielnie, po reversie, bo ma być non-inc, tak jak dla crll non-desc */
    /*         // w teorii mogę być lazy, i po prostu 2 razy całość porobić brrr */
    /*         for(int x = crrr; x >= crll; --x) */
    /*             crrr = max(crrr, rr[x]); */
    /*         FORR(x,i){ */
    /*             ll[x] = crll; */
    /*             rr[x] = crrr; */
    /*         } */
    /*     } */
    /*     reverse(all(scc)); */
    /* } */
    // wow, that's one heck of a seemingly small subproblem
    /* for(int i = 0; i < n; ++i){ */
    /*     whatis(i) */
    /*     whatis(ll[i]) */
    /*     whatis(rr[i]) */
    /* } */
    /* vector<pair<int,int64_t>> vec[n]; // [lrange_r] -> {lrange_l, cnt} */
    // nie multiset / mapa?
    // mapa w sumie tutaj ma znacznie większy sens, niż set
    /* set<pair<int,int64_t>> vec[n]; // [lrange_r] -> {lrange_l, cnt} */
    // w teorii 0..n-1 key range, but memory i guess
    map<int,int64_t> vec[n]; // [lrange_r] -> {lrange_l, cnt}
    // sofar czasy z mapą nielepsze
    int64_t crsum[n];
    memset(crsum,0,sizeof crsum);
    /* int64_t empty = 0; */
    int64_t empty = 1;
    // todo modula
    FOR(i,0,n){
        /* whatis(i) */
        /* whatis(empty) */
        /* if(i){ */
        /* whatis(crsum[i-1]) */
        /* whatis(vec[i-1]) */
        /* } */
        if(ll[i] == i){
            /* vec[ll[i]].push_back({rr[i], empty}); */
            /* vec[rr[i]].push_back({ll[i], empty}); */
            /* vec[rr[i]].insert({ll[i], empty}); */
            vec[rr[i]][ll[i]] += empty;
            vec[rr[i]][ll[i]] %= mod;
            crsum[rr[i]] += empty;
            if(crsum[rr[i]] >= mod)
                crsum[rr[i]] -= mod;
        }
        if(i){
            /* int64_t crsum = 0; */

            /* FORR(x,vec[i-1]){ */
            /*     // wa below */
            /*     /1* if(x.e1 >= ll[i]){ *1/ */
            /*     if(x.e1 <= ll[i]){ */
            /*         // -> nice, passes sample */
            /*         /1* crsum += x.e2; *1/ */
            /*         vec[rr[i]].push_back({x.e1, x.e2}); */
            /*     } */
            /*     empty += x.e2; */
            /*     if(empty >= mod) */
            /*         empty -= mod; */
            /* } */

            empty += crsum[i-1];
            if(empty >= mod)
                empty -= mod;
            /*     if(empty >= mod) */
            /*         empty -= mod; */
            // czemu e2 porównywałem lol
            /* while(!vec[i-1].empty() && (--vec[i-1].end())->e2 > ll[i]){ */
            // bez zmiany po przejściu na mapę
            while(!vec[i-1].empty() && (--vec[i-1].end())->e1 > ll[i]){
                crsum[i-1] -= (--vec[i-1].end())->second;
                crsum[i-1] = (crsum[i-1] + mod) % mod;
                vec[i-1].erase(--vec[i-1].end());
            }

            crsum[rr[i]] += crsum[i-1];
            crsum[rr[i]] %= mod;

            // smaller to bigger
            // bug z tym swappem jakiś

            if(vec[i-1].size() <= vec[rr[i]].size()){
                FORR(x,vec[i-1]){
                    /* vec[rr[i]].insert(x); */
                    vec[rr[i]][x.e1] += x.e2;
                    vec[rr[i]][x.e1] %= mod;
                }
            }
            else{
                FORR(x,vec[rr[i]]){
                    /* vec[rr[i]].insert(x); */
                    vec[i-1][x.e1] += x.e2;
                    vec[i-1][x.e1] %= mod;
                }
                vec[i-1].swap(vec[rr[i]]); // tera działa somehow :o
            }

            /* bool swpd = 0; */
            /* if(vec[i-1].size() > vec[rr[i]].size()){ */
            /*     swpd = 1; */
            /*     vec[i-1].swap(vec[rr[i]]); */
            /* } */
            /* // czy nie potrzebuję multiseta? */
            /* // mapa w sumie tutaj ma znacznie większy sens, niż set */

            /* // wait, czy wynik tego really jest niezależny od strony? */
            /* // bo wa ze swapem */
            /* FORR(x,vec[i-1]){ */
            /*     /1* vec[rr[i]].insert(x); *1/ */
            /*     vec[rr[i]][x.e1] += x.e2; */
            /*     vec[rr[i]][x.e1] %= mod; */
            /* } */

            /* if(swpd){ */
            /*     vec[i-1].swap(vec[rr[i]]); */
            /* } */

            // jednak nie tak -> lrange_l = x.e1 (remains), a nie ll[i]
            // -> musze rozróżnić to -> chyba segtree potrzebne jednak
            /* vec[rr[i]].push_back({ll[i], crsum}); */

            vec[i-1].clear(); // on a set/map this does free memory
        }
    }
    int64_t res = 0;
    res += empty;
    FORR(i,vec[n-1]){
        res += i.e2;
        // eq crsum[n-1]
        if(res >= mod)
            res -= mod;
    }
    cout << res << '\n';
}