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



"""
class Node:
    def __init__(self,key):
        self.left = None
        self.right = None
        self.val = key

"""




"""""
#bst insertion    
            
def insert(node, data): 
  
    # 1. If the tree is empty, return a new, 
    # single node 
    if node is None: 
        return (Node(data)) 
  
    else: 
        # 2. Otherwise, recur down the tree 
        if data <= node.data: 
            node.left = insert(node.left, data) 
        else: 
            node.right = insert(node.right, data) 
  
        # Return the (unchanged) node pointer 
        return node 
        
"""

"""
# delete bst 


 # A utility function to do inorder traversal of BST
def inorder(root):
    if root is not None:
        inorder(root.left)
        print
        root.key,
        inorder(root.right)

    # A utility function to insert a new node with given key in BST


def insert(node, key):
    # If the tree is empty, return a new node
    if node is None:
        return Node(key)

        # Otherwise recur down the tree
    if key < node.key:
        node.left = insert(node.left, key)
    else:
        node.right = insert(node.right, key)

        # return the (unchanged) node pointer
    return node


# Given a non-empty binary search tree, return the node
# with minum key value found in that tree. Note that the
# entire tree does not need to be searched
def minValueNode(node):
    current = node

    # loop down to find the leftmost leaf
    while (current.left is not None):
        current = current.left

    return current


# Given a binary search tree and a key, this function
# delete the key and returns the new root
def deleteNode(root, key):
    # Base Case
    if root is None:
        return root

        # If the key to be deleted is smaller than the root's
    # key then it lies in  left subtree
    if key < root.key:
        root.left = deleteNode(root.left, key)

        # If the kye to be delete is greater than the root's key
    # then it lies in right subtree
    elif (key > root.key):
        root.right = deleteNode(root.right, key)

        # If key is same as root's key, then this is the node
    # to be deleted
    else:

        # Node with only one child or no child
        if root.left is None:
            temp = root.right
            root = None
            return temp

        elif root.right is None:
            temp = root.left
            root = None
            return temp

            # Node with two children: Get the inorder successor
        # (smallest in the right subtree)
        temp = minValueNode(root.right)

        # Copy the inorder successor's content to this node
        root.key = temp.key

        # Delete the inorder successor
        root.right = deleteNode(root.right, temp.key)

    return root


"""

z = int(input())
x = []
h = []
if z < 2:
    count = 1
else:
    count = 2
while z > 0 :
    l = []
    l = list (map(int,input().split()))

    x.append(l[0])
    h.append(l[1])
    z-=1




for i in range(1 , len(x)-1):

    if abs (x[i-1] - x[i]) > h[i] :
        count += 1
    elif abs(x[i+1]- x[i])  > h[i]:
        count += 1
        x[i] += h[i]

print (count)

























 


 
