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.util.*;
		import java.io.*;
		 public class Main {
			public static boolean visited[]; 
			public static Integer distances[];
				
		    public static void main ( String args[] ) throws IOException {
		    	FastReader sc = new FastReader();
		    	int n = sc.nextInt(); 
		    	int positions[] = new int [n]; 
		    	int heights[] = new int [n]; 
		    	
		    	for(int i = 0 ; i <n;i++) {positions[i] = sc.nextInt() ; heights[i]= sc.nextInt(); }
		    	int count = n>1?2:1;
		    	for(int i = 1 ; i<n-1 ; i++) {
		    		if(positions[i]-heights[i]>positions[i-1])
		    			count++; 
		    		else if (positions[i]+heights[i]<positions[i+1]){
		    				count++; 
		    				positions[i]+=heights[i]; 
		    	}
		    	}
		    		System.out.println(count); 
		    	
		    }
		    public static int gcdExtended(int a, int b, int x, int y) 
		    { 
		        // Base Case 
		        if (a == 0) 
		        { 
		            x = 0; 
		            y = 1; 
		            return b; 
		        } 
		  
		        int x1=1, y1=1; // To store results of recursive call 
		        int gcd = gcdExtended(b%a, a, x1, y1); 		        // call 
		        x = y1 - (b/a) * x1; 
		        y = x1; 
		  
		        return gcd; 
		    }
		    			
		    	
		     static class Graph
		    {
		        public int V;  
		        public LinkedList<Integer> adj[];
 		        Graph(int v)
		        {
		            V = v;
		            visited = new boolean[v+1]; 
		            distances = new Integer[v+1]; 
		            for(int i = 0 ; i <v+1 ; i++)
		            	distances[i] = -1  ;
		            adj = new LinkedList[v+1];
		            for (int i=0; i<v+1; ++i)
		                adj[i] = new LinkedList<Integer>();
		        }
		        void addEdge(int v, int w)
		        {
		            adj[v].add(w); 
		        }
		        void dfs(int node) {
		        	visited[node]= true; 
		        	System.out.print(node+" ");
		        	for(int x :adj[node]) {
		        		if(!visited[x])
		        			dfs(x); 
		        	}
		        	
		        }
		        void bfs(int node){
		            Queue<Integer> q = new LinkedList<Integer>();   ;
		            distances[node]= 0 ;
		            q.add(node);
		            while(!q.isEmpty()){
		                int src = q.peek();
		                System.out.print(src+" ");
		                q.remove();
		                int cost = distances[src];
		                for(int child : adj[src]){
		                    if(distances[child]==-1){
		                        q.add(child);
		                        distances[child]= cost+1;
		                    }
		                }
		            }
		        }
		        public  int graph_height(int node) {
		        	int h = 0 ; 
		        	for(int x : adj[node])
		        		h= Math.max(h,1+graph_height(x));
		  
		        return h ; 
		          
		    }
		    }
		     
		    static class FastReader
			{
				BufferedReader br;
				StringTokenizer st;
 
				public FastReader() {
					  
					   br = new BufferedReader(new InputStreamReader(System.in));
				}
 
				String next()
				{
					while (st == null || !st.hasMoreElements())
					{
						try
						{
							st = new StringTokenizer(br.readLine());
						}
						catch (IOException  e)
						{
							e.printStackTrace();
						}
					}
					return st.nextToken();
				}
 
				int nextInt()
				{
					return Integer.parseInt(next());
				}
 
				long nextLong()
				{
					return Long.parseLong(next());
				}
 
				double nextDouble()
				{
					return Double.parseDouble(next());
				}
 
				String nextLine()
				{
					String str = "";
					try
					{
						str = br.readLine();
					}
					catch (IOException e)
					{
						e.printStackTrace();
					}
					return str;
				}
				public boolean ready() throws IOException {
					return br.ready();
				}
		}
		 }
		  class Pair {
			int x ;
			int y ;
			public Pair(int x ,int y){
				this.x = x;
				this.y=y;}
		}
 
		  class Pair1 implements Comparable{
			int x ;
			int y ;
			public Pair1(int x ,int y){
				this.x = x;
				this.y=y;}
			public int compareTo(Object o) {
				Pair1 a = (Pair1) o ;
 
				return (this.x-a.x);
			}
 
			}
		 class Pair2 implements Comparable{
			int x ;
			int y ;
			public Pair2(int x ,int y){
				this.x = x;
				this.y=y;}
			public int compareTo(Object o) {
				Pair2 a = (Pair2) o ;
 
				return (this.y-a.y);
			}
		 }
		 
		 
