4
10 4
15 1
19 3
20 1
 2
1 999999999
1000000000 1000000000
 67
1 1
3 8
4 10
7 8
9 2
10 1
11 5
12 8
13 4
16 6
18 3
19 3
22 5
24 6
27 5
28 3
29 3
30 5
32 5
33 10
34 7
35 8
36 5
41 3
42 2
43 5
46 4
48 4
49 9
52 4
53 9
55 1
56 4
59 7
68 7
69 4
71 9
72 10
74 5
76 4
77 9
80 7
81 9
82 5
83 5
84 9
85 7
86 9
87 4
88 7
89 10
90 3
91 5
92 10
93 5
94 8
95 4
96 2
97 10
98 1
99 3
100 1
101 5
102 4
103 8
104 8
105 8
 10
999999900 1000000000
999999901 1000000000
999999902 1000000000
999999903 1000000000
999999904 1000000000
999999905 1000000000
999999906 1000000000
999999907 1000000000
999999908 1000000000
999999909 1000000000
 35
1 7
3 11
6 12
7 6
8 5
9 11
15 3
16 10
22 2
23 3
25 7
27 3
34 5
35 10
37 3
39 4
40 5
41 1
44 1
47 7
48 11
50 6
52 5
57 2
58 7
60 4
62 1
67 3
68 12
69 8
70 1
71 5
72 5
73 6
74 4
 1
1000000000 1000000000
 2
100000000 1000000000
1000000000 1000000000
 10
7 12
10 2
12 2
15 1
19 2
20 1
53 25
63 10
75 12
87 1
 3
1 1
1000 1000
1000000000 1000000000
 40
1 1
2 1
3 1
4 1
5 1
6 1
7 1
8 1
9 1
10 1
11 1
12 1
13 1
14 1
15 1
16 1
17 1
18 1
19 1
20 1
21 1
22 1
23 1
24 1
25 1
26 1
27 1
28 1
29 1
30 1
31 1
32 1
33 1
34 1
35 1
36 1
37 1
38 1
39 1
40 1

4
 2
 5
 2
 10
 1
 2
 9
 3
 2

"""
    Author - Satwik Tiwari .
    2nd NOV , 2020  - Monday
"""

#===============================================================================================
#importing some useful libraries.


from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase
from functools import cmp_to_key

# from itertools import *
from heapq import *
from math import gcd, factorial,floor,ceil,sqrt

from copy import deepcopy
from collections import deque


from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect

#==============================================================================================
#fast I/O region
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

# inp = lambda: sys.stdin.readline().rstrip("\r\n")

#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
  def wrapped_func(*args, **kwargs):
    if stack: return f(*args, **kwargs)
    to = f(*args, **kwargs)
    while True:
      if type(to) is GeneratorType:
        stack.append(to)
        to = next(to)
        continue
      stack.pop()
      if not stack: break
      to = stack[-1].send(to)
    return to
  return wrapped_func
#### END ITERATE RECURSION ####

#===============================================================================================
#some shortcuts

def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var))  #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n")  #as stdout.write always print sring.
def testcase(t):
    for pp in range(t):
        solve(pp)
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def google(p):
    print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
    y%=(p-1)  #not so sure about this. used when y>p-1. if p is prime.
    res = 1     # Initialize result
    x = x % p  # Update x if it is more , than or equal to p
    if (x == 0) :
        return 0
    while (y > 0) :
        if ((y & 1) == 1) : # If y is odd, multiply, x with result
            res = (res * x) % p

        y = y >> 1      # y = y/2
        x = (x * x) % p
    return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True
inf = pow(10,20)
mod = 998244353
#===============================================================================================
# code here ;))

def bucketsort(order, seq):
    buckets = [0] * (max(seq) + 1)
    for x in seq:
        buckets[x] += 1
    for i in range(len(buckets) - 1):
        buckets[i + 1] += buckets[i]

    new_order = [-1] * len(seq)
    for i in reversed(order):
        x = seq[i]
        idx = buckets[x] = buckets[x] - 1
        new_order[idx] = i

    return new_order


def ordersort(order, seq, reverse=False):
    bit = max(seq).bit_length() >> 1
    mask = (1 << bit) - 1
    order = bucketsort(order, [x & mask for x in seq])
    order = bucketsort(order, [x >> bit for x in seq])
    if reverse:
        order.reverse()
    return order


def long_ordersort(order, seq):
    order = ordersort(order, [int(i & 0x7fffffff) for i in seq])
    return ordersort(order, [int(i >> 31) for i in seq])


def multikey_ordersort(order, *seqs, sort=ordersort):
    for i in reversed(range(len(seqs))):
        order = sort(order, seqs[i])
    return order

dp = [[-1,-1,-1] for i in range(100010)]

@iterative
def rec(pos,type):
    global p,h
    if(pos>=len(p)):
        yield 0
    if(dp[pos][type] != -1):
        yield dp[pos][type]

    temp = 0
    temp = max(temp,(yield rec(pos+1,1)))
    if(type == 0):
        if(p[pos]-h[pos]>p[pos-1]):
            temp = max(temp,1+(yield rec(pos+1,0)))
        if(pos == len(p)-1 or p[pos+1]>p[pos]+h[pos]):
            temp = max(temp,1+(yield rec(pos+1,2)))
    if(type == 2):
        if(p[pos-1]+h[pos-1] < p[pos]-h[pos]):
            temp = max(temp,1+(yield rec(pos+1,0)))
        if(pos == len(p)-1 or p[pos+1]>p[pos] + h[pos]):
            temp = max(temp,1+(yield rec(pos+1,2)))
    if(type == 1):
        if(pos == 0 or p[pos-1]<p[pos]-h[pos]):
            temp = max(temp,1+(yield rec(pos+1,0)))
        if(pos == len(p)-1 or p[pos+1]>p[pos]+h[pos]):
            temp = max(temp,1+(yield rec(pos+1,2)))

    dp[pos][type] = temp
    # print(temp,pos)
    yield temp

def solve(case):
    n = int(inp())
    a,b = [],[]
    for i in range(n):
        x,y  =sep()
        a.append(x)
        b.append(y)

    order = multikey_ordersort(range(n),a,b)
    global p,h
    p = []
    h = []
    for i in order:
        p.append(a[i])
        h.append(b[i])

    # print(p)
    # print(h)
    print(rec(0,1))






p = []
h = []
testcase(1)
# testcase(int(inp()))









