// Marcin Knapik

// Potyczki Algorytmiczne 2020 - Runda trzecia zadanie B

#pragma GCC optimize "O3" 
#include<bits/stdc++.h>
using namespace std;

#define f first
#define s second
#define sz(s) (int)s.size()
#define pb push_back
#define all(s) s.begin(), s.end()

#define ii pair<int, int> 
#define ll long long
#define pll pair<ll, ll>

#define vi vector<int>
#define vii vector<ii>
#define vll vector<ll>
#define vpll vector<pll>

const int N = 1e6 + 7;
const int T = (1 << 20);
const int INF = 1e9 + 7;
const int mod = 1e9 + 7;

const ll BIG_INF = 2e18 + 10000;

ii tree[T + T];
int lazy[T + T];

void push(int u){
    tree[u].f += lazy[u];
    if(u < T){
        lazy[u + u] += lazy[u];
        lazy[u + u + 1] += lazy[u];
    }
    lazy[u] = 0;
}

void add(int pocz, int kon, int val, int u = 1, int lo = 0, int hi = T - 1){
    push(u);
    if(pocz > hi or kon < lo)
        return;
    if(pocz <= lo and hi <= kon){
        lazy[u] += val;
        push(u);
        return;
    }
    int mid = (lo + hi) / 2;
    add(pocz, kon, val, u + u, lo, mid);
    add(pocz, kon, val, u + u + 1, mid + 1, hi);
    tree[u] = min(tree[u + u], tree[u + u + 1]);
}

ii first_min(int pocz, int kon, int u = 1, int lo = 0, int hi = T - 1){
    // cout << lo << ' ' << hi << endl;
    push(u);
    if(pocz > hi or kon < lo)
        return {INF, INF};
    if(pocz <= lo and hi <= kon)
        return tree[u];
    int mid = (lo + hi) / 2;
    return min(first_min(pocz, kon, u + u, lo, mid), first_min(pocz, kon, u + u + 1, mid + 1, hi));
}

int n;
map<ii, vi> mapa_przedzialow;
map<ii, vii> mapa_bazowe;
vii przedzialy;

void req_policz_bazowe(int pocz, int kon, ii z_goory_lewo = {-1, -1}, ii z_goory_prawo = {-1, -1}){
    if(pocz > kon)
        return;
    // if(sz(mapa))
    ii pierwszy_bazowy = first_min(pocz, kon);

    // cout << "POCZ KON " << 
    assert(pierwszy_bazowy.f == 1);

    while(1){
        if(pierwszy_bazowy.f > 1)
            break;
        ii przedz = przedzialy[pierwszy_bazowy.s];

        mapa_bazowe[{pocz, kon}].pb(przedz);
        if(z_goory_lewo != make_pair(-1, -1) and przedz.f <= z_goory_lewo.s)
            mapa_bazowe[z_goory_lewo].pb(przedz);
        if(z_goory_prawo != make_pair(-1, -1) and przedz.s >= z_goory_prawo.f)
            mapa_bazowe[z_goory_prawo].pb(przedz);
        
        if(pierwszy_bazowy.s == kon)
            break;

        pierwszy_bazowy = first_min(przedz.s + 1, kon);
    }

    vii & vec = mapa_bazowe[{pocz, kon}];
    sort(all(vec));
    vec.resize(unique(all(vec)) - vec.begin());
    
    for(auto & u : vec)
        add(u.f, u.s, -1);

    req_policz_bazowe(pocz, mapa_przedzialow[vec[0]][0] - 1);
    req_policz_bazowe(mapa_przedzialow[vec.back()].back() + 1, kon);

    for(auto & u : vec)
        for(int i = 0; i < sz(mapa_przedzialow[u]) - 1; i++)
            req_policz_bazowe(mapa_przedzialow[u][i] + 1, mapa_przedzialow[u][i + 1] - 1);
    
    for(int i = 0; i < sz(vec) - 1; i++){
        int a = mapa_przedzialow[vec[i]].back() + 1;
        int b = mapa_przedzialow[vec[i + 1]][0] - 1;
        req_policz_bazowe(a, b, {a, vec[i + 1].f - 1}, {vec[i].s + 1, b});
    }

}

map<ii, int> mapa_req;

int req(int pocz, int kon){
    if(pocz > kon)
        return 1;
    if(mapa_req.count({pocz, kon}))
        return mapa_req[{pocz, kon}];
    
    // cout << "REQ " << pocz << ' ' << kon << endl;

    vii & vec = mapa_bazowe[{pocz, kon}];
    if(sz(vec) == 0){
        assert(pocz == kon);
        vec.pb({pocz, kon});
    }
    assert(sz(vec));

    int _1 = 1;
    int _0 = req(pocz, mapa_przedzialow[vec[0]][0] - 1);
    // cout << "ROZMIAR " << sz(mapa_przedzialow[vec[0]]) << ' ' << vec[0].f << ' ' << vec[0].s << endl;
    for(int i = 0; i < sz(mapa_przedzialow[vec[0]]) - 1; i++)
        _0 = 1ll * _0 * req(mapa_przedzialow[vec[0]][i] + 1, mapa_przedzialow[vec[0]][i + 1] - 1) % mod;
    // cout << "POCZ KON " << pocz << ' ' << kon << ' ' << _0 << ' ' << _1 << endl;

    for(int i = 1; i < sz(vec); i++){
        int nowe_1 = (_1 + 1ll * _0 * req(mapa_przedzialow[vec[i - 1]].back() + 1, vec[i].f - 1)) % mod;   
        int nowe_0 = (1ll * _1 * req(vec[i - 1].s + 1, mapa_przedzialow[vec[i]][0] - 1) +
                     1ll * _0 * req(mapa_przedzialow[vec[i - 1]].back() + 1, mapa_przedzialow[vec[i]][0] - 1)) % mod;
        for(int j = 0; j < sz(mapa_przedzialow[vec[i]]) - 1; j++)
            nowe_0 = 1ll * nowe_0 * req(mapa_przedzialow[vec[i]][j] + 1, mapa_przedzialow[vec[i]][j + 1] - 1) % mod;
        // cout << "_0 i _1 oraz nowe_0 i nowe_1 " << _0 << ' ' << _1 << ' ' << nowe_0 << ' ' << nowe_1 << endl;
        swap(_0, nowe_0);
        swap(_1, nowe_1);
    }
    _0 = 1ll * _0 * req(mapa_przedzialow[vec.back()].back() + 1, kon) % mod;

    return mapa_req[{pocz, kon}] = (_0 + _1) % mod;
}

pair<ll, ll> TREE_PRAWO[T * 2];
pair<ll, ll> TREE_LEWO[T * 2];

pll ask_PRAWO(int pocz, int kon){
    if(pocz > kon)
        return {-BIG_INF, 0};

    pocz += T;
    kon += T;

    pll ret = max(TREE_PRAWO[pocz], TREE_PRAWO[kon]);

    while(pocz / 2 != kon / 2){
        if(pocz % 2 == 0)
            ret = max(ret, TREE_PRAWO[pocz + 1]);
        if(kon & 1)
            ret = max(ret, TREE_PRAWO[kon - 1]);
        pocz /= 2;
        kon /= 2;
    }
    return ret;
}

pll ask_LEWO(int pocz, int kon){
    if(pocz > kon)
        return {BIG_INF, 0};

    pocz += T;
    kon += T;

    pll ret = min(TREE_LEWO[pocz], TREE_LEWO[kon]);

    while(pocz / 2 != kon / 2){
        if(pocz % 2 == 0)
            ret = min(ret, TREE_LEWO[pocz + 1]);
        if(kon & 1)
            ret = min(ret, TREE_LEWO[kon - 1]);
        pocz /= 2;
        kon /= 2;
    }

    return ret;
}

void PRAWO_set(int poz, pll val){
    poz += T;
    TREE_PRAWO[poz] = val;
    poz /= 2;

    while(poz){
        TREE_PRAWO[poz] = max(TREE_PRAWO[poz + poz], TREE_PRAWO[poz + poz + 1]);
        poz /= 2;
    }
}

void LEWO_set(int poz, pll val){
    poz += T;
    TREE_LEWO[poz] = val;
    poz /= 2;

    while(poz){
        TREE_LEWO[poz] = min(TREE_LEWO[poz + poz], TREE_LEWO[poz + poz + 1]);
        poz /= 2;
    }
}
vll poz, range;

void zaraza(int poz2, vi & ret, int best){
    ret[poz2] = best;
    PRAWO_set(poz2, {-BIG_INF, 0});
    LEWO_set(poz2, {BIG_INF, 0});

    pll pom = ask_PRAWO(0, poz2 - 1);

    while(pom.f >= poz[poz2]){
        zaraza(pom.s, ret, best);
        pom = ask_PRAWO(0, poz2 - 1);    
    }

    pom = ask_LEWO(poz2 + 1, n - 1);

    while(pom.f <= poz[poz2]){
        zaraza(pom.s, ret, best);
        pom = ask_LEWO(poz2 + 1, n - 1);
    }
}

vi rob_lewo(){
    vi ret(n, INF);
    for(int i = 0; i < n; i++)
        LEWO_set(i, {poz[i] - range[i], i});
    for(int i = 0; i < n; i++)
        PRAWO_set(i, {poz[i] + range[i], i});

    for(int i = 0; i < n; i++)
        if(ret[i] == INF){
            // cout << "SIEMA " << i << endl;
            // for(int j = 0; j < n; j++)
            //     cout << ret[j] << ' ';
            // cout << endl;
            // for(int j = 0; j < n; j++)
            //     cout << ask_LEWO(j, j).f << ' ';
            // cout << endl;
            zaraza(i, ret, i);
        }

    return ret;
}

vi rob_prawo(){
    vi ret(n, -INF);
    for(int i = 0; i < n; i++)
        LEWO_set(i, {poz[i] - range[i], i});
    for(int i = 0; i < n; i++)
        PRAWO_set(i, {poz[i] + range[i], i});

    for(int i = n - 1; i >= 0; i--)
        if(ret[i] == -INF)
            zaraza(i, ret, i);

    return ret;
}

#define vvi vector<vector<int> >
int result(vvi & G, int mask){
    vi odw(n);
    queue<int> kol;

    for(int i = 0; i < n; i++)
        if(mask & (1 << i)){
            kol.push(i);
            odw[i] = 1;
        }

    while(sz(kol)){
        int akt = kol.front();
        kol.pop();

        for(auto & u : G[akt])
            if(!odw[u]){
                odw[u] = 1;
                kol.push(u);
            }
    }

    int ret = 0;
    for(int i = 0; i < n; i++)
        if(odw[i])
            ret += (1 << i);
    return ret;
}


int main(){
    ios::sync_with_stdio(0);
    cin.tie(0);

    cin >> n;

    for(int i = T; i < T + T; i++)
        tree[i] = {0, i - T};
    for(int i = T - 1; i >= 1; i--)
        tree[i] = min(tree[i + i], tree[i + i + 1]);

    for(int i = 0; i < n; i++){
        ll a, b; cin >> a >> b;
        poz.pb(a); range.pb(b);
    }

    if(n <= 20){
        vvi G(n);

        for(int i = 0; i < n; i++)
            for(int j = 0; j < n; j++)
                if(abs(poz[i] - poz[j]) <= range[i])
                    G[i].pb(j);

        set<int> maski;

        for(int mask = 0; mask < (1 << n); mask++)
            maski.insert(result(G, mask));

        cout << sz(maski) << '\n';
        exit(0);
    }

    // rob _jump
    vi jump_left = rob_lewo(), jump_right = rob_prawo();

    // for(int i = 0; i < n; i++){
    //     auto it = lower_bound(all(poz), poz[i] - range[i]);
    //     jump_left[i] = it - poz.begin();
    //     it = prev(upper_bound(all(poz), poz[i] + range[i]));
    //     jump_right[i] = it - poz.begin();
    // }


    // for(int j = 0; j < 20; j++){
    //     vi nowy_left(n), nowy_right(n);

    //     for(int i = 0; i < n; i++){
    //         nowy_left[i] = jump_left[jump_left[i]];
    //         nowy_right[i] = jump_right[jump_right[i]];
    //     }

    //     swap(nowy_right, jump_right);
    //     swap(nowy_left, jump_left);
    // }

    // for(int i = 0; i < n; i++)
    //     cout << jump_right[i] << ' ';
    // cout << endl;

    // for(int i = 0; i < n; i++)
    //     cout << jump_left[i] << ' ';
    // cout << endl;

    set<ii> dodane_przedzialy;
    for(int i = 0; i < n; i++){
        przedzialy.pb({jump_left[i], jump_right[i]});
        mapa_przedzialow[przedzialy[i]].pb(i);
        if(!dodane_przedzialy.count(przedzialy[i])){
            add(przedzialy[i].f, przedzialy[i].s, 1);
            dodane_przedzialy.insert(przedzialy[i]);
        }
    }

    req_policz_bazowe(0, n - 1);

    // for(auto & u : mapa_bazowe){
    //     cout << u.f.f << ' ' << u.f.s << "        ";
    //     for(auto & v : u.s)
    //         cout << v.f << ' ' << v.s << "    ";
    //     cout << endl;
    // }

    cout << req(0, n - 1) << '\n';

    // cout << endl;
    // for(auto & u : mapa_req)
    //     cout << u.f.f << ' ' << u.f.s << "     " << u.s << endl;
}