#include <bits/stdc++.h>
#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")
char __BUF[1 << 21];
char *__P1 = __BUF;
char *__P2 = __BUF;
namespace mystl {
template <class T>
inline bool rei(T &x) {
  register bool f = false;
  register int ch;
  for (ch = (__P1 == __P2 &&
                     (__P2 = (__P1 = __BUF) + fread(__BUF, 1, 1 << 21, stdin),
                     __P1 == __P2)
                 ? EOF
                 : *__P1++);
       !isdigit(ch);
       ch = (__P1 == __P2 &&
                     (__P2 = (__P1 = __BUF) + fread(__BUF, 1, 1 << 21, stdin),
                     __P1 == __P2)
                 ? EOF
                 : *__P1++)) {
    if (ch == EOF) {
      return false;
    }
    f = ch == '-';
  }
  for (x = 0; isdigit(ch);
       ch = (__P1 == __P2 &&
                     (__P2 = (__P1 = __BUF) + fread(__BUF, 1, 1 << 21, stdin),
                     __P1 == __P2)
                 ? EOF
                 : *__P1++)) {
    x = (x << 3) + (x << 1) + (ch & 15);
  }
  f ? x = -x : 0;
  return true;
}
inline int rec() {
  register int ch;
  for (ch = (__P1 == __P2 &&
                     (__P2 = (__P1 = __BUF) + fread(__BUF, 1, 1 << 21, stdin),
                     __P1 == __P2)
                 ? EOF
                 : *__P1++);
       isspace(ch);
       ch = (__P1 == __P2 &&
                     (__P2 = (__P1 = __BUF) + fread(__BUF, 1, 1 << 21, stdin),
                     __P1 == __P2)
                 ? EOF
                 : *__P1++))
    ;
  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);
}
}  // namespace mystl
using namespace std;
using namespace mystl;
const long long MAXN = 100005;
long long n;
struct Node {
  long long x, l;
  Node(long long x, long long l) : x(x), l(l) {}
  Node() {}
};
Node a[MAXN];
signed main() {
  rei(n);
  for (register long long i = 1, i_end = n; i <= i_end; ++i) {
    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; });
  long long r = 0xc0c0c0c0c0c0c0c0;
  long long cnt = 0;
  for (register long long i = 1, i_end = n; i <= i_end; ++i) {
    if (r <= a[i].x - a[i].l) {
      ++cnt;
      r = a[i].x + a[i].l;
    }
  }
  printf("%lld\n", cnt);
  return 0;
}
