// #include <zhaojinxi>
    #ifdef ONLINE_JUDGE
        #pragma GCC optimize(2)
        #pragma GCC optimize(3)
        #pragma GCC optimize("Ofast")
        #pragma GCC optimize("inline")
        #pragma GCC optimize("-fgcse")
        #pragma GCC optimize("-fgcse-lm")
        #pragma GCC optimize("-fipa-sra")
        #pragma GCC optimize("-ftree-pre")
        #pragma GCC optimize("-ftree-vrp")
        #pragma GCC optimize("-fpeephole2")
        #pragma GCC optimize("-ffast-math")
        #pragma GCC optimize("-fsched-spec")
        #pragma GCC optimize("unroll-loops")
        #pragma GCC optimize("-falign-jumps")
        #pragma GCC optimize("-falign-loops")
        #pragma GCC optimize("-falign-labels")
        #pragma GCC optimize("-fdevirtualize")
        #pragma GCC optimize("-fcaller-saves")
        #pragma GCC optimize("-fcrossjumping")
        #pragma GCC optimize("-fthread-jumps")
        #pragma GCC optimize("-funroll-loops")
        #pragma GCC optimize("-freorder-blocks")
        #pragma GCC optimize("-fschedule-insns")
        #pragma GCC optimize("inline-functions")
        #pragma GCC optimize("-ftree-tail-merge")
        #pragma GCC optimize("-fschedule-insns2")
        #pragma GCC optimize("-fstrict-aliasing")
        #pragma GCC optimize("-falign-functions")
        #pragma GCC optimize("-fcse-follow-jumps")
        #pragma GCC optimize("-fsched-interblock")
        #pragma GCC optimize("-fpartial-inlining")
        #pragma GCC optimize("no-stack-protector")
        #pragma GCC optimize("-freorder-functions")
        #pragma GCC optimize("-findirect-inlining")
        #pragma GCC optimize("-fhoist-adjacent-loads")
        #pragma GCC optimize("-frerun-cse-after-loop")
        #pragma GCC optimize("inline-small-functions")
        #pragma GCC optimize("-finline-small-functions")
        #pragma GCC optimize("-ftree-switch-conversion")
        #pragma GCC optimize("-foptimize-sibling-calls")
        #pragma GCC optimize("-fexpensive-optimizations")
        #pragma GCC optimize("inline-functions-called-once")
        #pragma GCC optimize("-fdelete-null-pointer-checks")
    #endif
    #ifndef DEBUG
        #define NDEBUG
    #endif
    #include <map>
    #include <set>
    #include <list>
    #include <cmath>
    #include <ctime>
    #include <queue>
    #include <stack>
    #include <bitset>
    #include <cctype>
    #include <cstdio>
    #include <string>
    #include <vector>
    #include <cassert>
    #include <climits>
    #include <cstdlib>
    #include <cstring>
    #include <fstream>
    #include <sstream>
    #include <iomanip>
    #include <iostream>
    #include <algorithm>
    #define itn int
    #define scnaf scanf
    #define pritnf printf
    #define szieof sizeof
    #define re register
    #define def(v) int &v = e[i].v
    #define cls(a) memset (a, 0, sizeof (a))
    #define ful(a) memset (a, 0x3f, sizeof (a))
    #define stfg(a) memset (a, 0xff, sizeof (a))
    #define mst(a, b) memset (a, b, sizeof (a))
    #define go(i,e,...) for (re int i = __VA_ARGS__; i; i = e[i].nt)
    #define fir(i,a,...) for (re int i = a, i ## _end = __VA_ARGS__; i <= i ## _end; ++i)
    #ifdef DEBUG
        #define debug(...) (\
            fprintf (stderr, "debug in %d: ", __LINE__),\
            fprintf (stderr, __VA_ARGS__),\
            fprintf (stderr, "\n")\
        )
        #define dbug(x) (std::cerr << #x " = " << (x) << std::endl)
    #else
        #define debug(...)
        #define dbug(...)
    #endif
    typedef long long LL;
    typedef long double LD;
    typedef unsigned long long ULL;
    #ifdef ONLINE_JUDGE
        char __BUF[1 << 21];
        char *__P1 = __BUF;
        char *__P2 = __BUF;
        #define getchar() (__P1 == __P2 && (__P2 = (__P1 = __BUF) + fread (__BUF, 1, 1 << 21, stdin), __P1 == __P2) ? EOF : *__P1++)
    #endif
    namespace mystl {
        template<class T>
        inline bool rei (T &x) {
            register bool f = false;
            register int ch;
            for (ch = getchar (); !isdigit (ch); ch = getchar ()) {
                if (ch == EOF) {
                    return false;
                }
                f = ch == '-';
            }
            for (x = 0; isdigit (ch); ch = getchar ()) {
                x = (x << 3) + (x << 1) + (ch & 15);
            }
            f ? x = -x : 0;
            return true;
        }
        #if __cplusplus >= 201103L
            template<class T, class... Args>
            inline bool rei (T& x, Args&... args) {
                if (!rei (x)) {
                    return false;
                }
                return rei (args...);
            }
        #endif
        inline int rec () {
            register int ch;
            for (ch = getchar (); isspace (ch); ch = getchar ());
            return ch;
        }
        template<class T, long long MIN, long long MAX>
        class arr {
            public:
                T a[MAX - MIN + 1], *b;
                arr () {
                    b = a - MIN;
                }
                operator T* () {
                    return b;
                }
                inline void memset (const int &x) {
                    ::memset (a, x, sizeof a);
                }
        };
        template<class T>
        inline T md (const T &a, const T &b) {
            return (a % b + b) % b;
        }
        template<class T>
        inline T& mde (T &a, const T &b) {
            return a = md (a, b);
        }
        template<class T1, class T2>
        inline T1& cmax (T1 &a, const T2 &b) {
            return a < b ? a = b : a;
        }
        template<class T1, class T2>
        inline T1& cmin (T1 &a, const T2 &b) {
            return a > b ? a = b : a;
        }
        template<class T>
        inline T lowbit (const T &x) {
            return x & -x;
        }
        template<class T>
        inline T highbit (T x) {
            x |= x >> 1;
            x |= x >> 2;
            x |= x >> 4;
            if (sizeof (T) >= 2) {
                x |= x >> 8;
                if (sizeof (T) >= 4) {
                    x |= x >> 16;
                    if (sizeof (T) >= 8) {
                        x |= x >> 32;
                    }
                }
            }
            return x & ~(x >> 1);
        }
        template<class T>
        inline T lg2 (T x) {
            x = highbit (x);
            return
                (x & 0xFFFFFFFF00000000 ? 32 : 0) +
                (x & 0xFFFF0000FFFF0000 ? 16 : 0) +
                (x & 0xFF00FF00FF00FF00 ? 8 : 0) +
                (x & 0xF0F0F0F0F0F0F0F0 ? 4 : 0) +
                (x & 0xCCCCCCCCCCCCCCCC ? 2 : 0) +
                (x & 0xAAAAAAAAAAAAAAAA ? 1 : 0);
        }
    }
    using namespace std;
    using namespace mystl;
#define int LL
const int MAXN = 100005;
int n;
struct Node {
    int x, l;
    Node (int x, int l) : x(x), l(l) {}
    Node () {}
};
Node a[MAXN];
signed main () {
    rei (n);
    fir (i, 1, n) {
        rei (a[i].x, a[i].l);
    }
    sort (a + 1, a + n + 1, [=] (const Node &a, const Node &b) {
        return a.x + a.l < b.x + b.l;
    });
    int r = 0xc0c0c0c0c0c0c0c0;
    int cnt = 0;
    fir (i, 1, n) {
        if (r <= a[i].x - a[i].l) {
            ++cnt;
            r = a[i].x + a[i].l;
        }
    }
    printf ("%lld\n", cnt);
    return 0;
}

Measured memory_bytes: 1792