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

import java.io.*;
import java.util.*;


public class CodeForces
{
        private static long[][] numbers;
        private static long[][] helper;
        private static int number;
   
    public static void main(String[] args) throws IOException 
	{
                Scanner in = new Scanner(System.in);
                int n = in.nextInt();
                int max =0;
                long stop ;
              //  boolean top_option = true ;
                long[][] points = new long[n][2];
                for(int i=0 ; i<n ; i++){
                    points[i][0] = in.nextLong();
                    points[i][1] = in.nextLong();
                }
              sort(points);
              stop = points[0][0];
              for(int i=0 ; i <n  ; i++){
                 
                       if(i == 0) max ++ ;
                       else if(i == n-1) max++;
                       else{
                           if(points[i][0] - points[i][1] > stop){
                               max ++ ;
                               stop = points[i][0] ;
                           }
                           else if(points[i][0] + points[i][1] < points[i+1][0]){
                               max ++ ;
                               stop = points[i][0] + points[i][1] ;
                           }
                           else {
                               stop = points[i][0] ;
                           }
                       }      
              }  
              System.out.println(max);
        }
 
  
 
  
  
  public static void sort(long[][] values) {
    numbers = values;
    number = values.length;
    helper = new long[number][2];
    mergesort(0, number - 1);
  }

  private static void mergesort(int low, int high) {
  
    if (low < high) {
     
      int middle = low + (high - low) / 2;
      
      mergesort(low, middle);
     
      mergesort(middle + 1, high);
     
      merge(low, middle, high);
    }
  }

  private static void merge(int low, int middle, int high) {

      for (int i = low; i <= high; i++) {
      helper[i][0] = numbers[i][0];
      helper[i][1] = numbers[i][1];
    }

    int i = low;
    int j = middle + 1;
    int k = low;

    while (i <= middle && j <= high) {
      if (helper[i][0] <= helper[j][0] ) {
        numbers[k][0] = helper[i][0];
        numbers[k][1] = helper[i][1];
        i++;
      } else {
        numbers[k][0] = helper[j][0];
        numbers[k][1] = helper[j][1];
        j++;
      }
      k++;
    }
    while (i <= middle) {
      numbers[k][0] = helper[i][0];
      numbers[k][1] = helper[i][1];
      k++;
      i++;
    }
    while (j <= high) {
      numbers[k][0] = helper[j][0];
      numbers[k][1] = helper[j][1];
      k++;
      j++;
    }
  }
}