Hands that shed innocent blood!

There are n guilty people in a line, the i-th of them holds a claw with length Li. The bell rings and every person kills some of people in front of him. All people kill others at the same time. Namely, the i-th person kills the j-th person if and only if j < i and j ≥ i - Li.

You are given lengths of the claws. You need to find the total number of alive people after the bell rings.

Input

The first line contains one integer n (1 ≤ n ≤ 106) — the number of guilty people.

Second line contains n space-separated integers L1, L2, ..., Ln (0 ≤ Li ≤ 109), where Li is the length of the i-th person's claw.

Output

Print one integer — the total number of alive people after the bell rings.

Examples

Input

4
0 1 0 10


Output

1


Input

2
0 0


Output

2


Input

10
1 1 3 0 0 0 2 1 0 3


Output

3

Note

In first sample the last person kills everyone in front of him.
	import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.InputMismatchException;
			
				 
				public class Solution1 implements Runnable
				{
					static final int MAX = 1000000007;
					static class InputReader
					{
						private InputStream stream;
						private byte[] buf = new byte[1024];
						private int curChar;
						private int numChars;
						private SpaceCharFilter filter;
						private BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
				
						public InputReader(InputStream stream)
						{
							this.stream = stream;
						}
						
						public int read()
						{
							if (numChars==-1) 
								throw new InputMismatchException();
							
							if (curChar >= numChars)
							{
								curChar = 0;
								try 
								{
									numChars = stream.read(buf);
								}
								catch (IOException e)
								{
									throw new InputMismatchException();
								}
								
								if(numChars <= 0)				
									return -1;
							}
							return buf[curChar++];
						}
					 
						public String nextLine()
						{
							String str = "";
				            try
				            {
				                str = br.readLine();
				            }
				            catch (IOException e)
				            {
				                e.printStackTrace();
				            }
				            return str;
						}
						public int nextInt()
						{
							int c = read();
							
							while(isSpaceChar(c)) 
								c = read();
							
							int sgn = 1;
							
							if (c == '-') 
							{
								sgn = -1;
								c = read();
							}
							
							int res = 0;
							do 
							{
								if(c<'0'||c>'9') 
									throw new InputMismatchException();
								res *= 10;
								res += c - '0';
								c = read();
							}
							while (!isSpaceChar(c)); 
							
							return res * sgn;
						}
						
						public long nextLong() 
						{
							int c = read();
							while (isSpaceChar(c))
								c = read();
							int sgn = 1;
							if (c == '-') 
							{
								sgn = -1;
								c = read();
							}
							long res = 0;
							
							do 
							{
								if (c < '0' || c > '9')
									throw new InputMismatchException();
								res *= 10;
								res += c - '0';
								c = read();
							}
							while (!isSpaceChar(c));
								return res * sgn;
						}
						
						public double nextDouble() 
						{
							int c = read();
							while (isSpaceChar(c))
								c = read();
							int sgn = 1;
							if (c == '-') 
							{
								sgn = -1;
								c = read();
							}
							double res = 0;
							while (!isSpaceChar(c) && c != '.') 
							{
								if (c == 'e' || c == 'E')
									return res * Math.pow(10, nextInt());
								if (c < '0' || c > '9')
									throw new InputMismatchException();
								res *= 10;
								res += c - '0';
								c = read();
							}
							if (c == '.') 
							{
								c = read();
								double m = 1;
								while (!isSpaceChar(c)) 
								{
									if (c == 'e' || c == 'E')
										return res * Math.pow(10, nextInt());
									if (c < '0' || c > '9')
										throw new InputMismatchException();
									m /= 10;
									res += (c - '0') * m;
									c = read();
								}
							}
							return res * sgn;
						}
						
						public String readString() 
						{
							int c = read();
							while (isSpaceChar(c))
								c = read();
							StringBuilder res = new StringBuilder();
							do 
							{
								res.appendCodePoint(c);
								c = read();
							} 
							while (!isSpaceChar(c));
							
							return res.toString();
						}
					 
						public boolean isSpaceChar(int c) 
						{
							if (filter != null)
								return filter.isSpaceChar(c);
							return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
						}
					 
						public String next() 
						{
							return readString();
						}
						
						public interface SpaceCharFilter 
						{
							public boolean isSpaceChar(int ch);
						}
					}
				 	
					public static void main(String args[]) throws Exception
					{
						new Thread(null, new Solution1(),"Solution1",1<<26).start();
					}
					
					public void run()
					{
						InputReader sc= new InputReader(System.in);
						PrintWriter w= new PrintWriter(System.out);
						int n = sc.nextInt();
						int[] arr =  new int[n];
						for(int i = 0;i < n;i++){
							arr[i]  =sc.nextInt();
						}
						int count = 0;
						int[] range=  new int[n+1];
						for(int i = 0;i < n;i++){
							if(arr[i] == 0){
								continue;
							}
							if(i - arr[i] < 0){
								range[0]++;
							}else{
								range[i-arr[i]]++;
							}
							range[i]--;
						}
						for(int i = 1;i < n;i++){
							range[i] += range[i-1];
						}
						for(int i = 0;i < n;i++){
							if(range[i] == 0){
								count++;
							}
						}
						w.println(count);
						w.close();
					}
					ArrayList<Integer> prime = new ArrayList();
					void seive(){
						boolean[] prim = new boolean[50005];
						Arrays.fill(prim,true);
						for(int i = 2;i*i<50005;i++){
							if(prim[i]){
								for(int j = 2*i;j < 50005;j += i){
									prim[j] = false;
								}
							}
						}
						for(int i = 2;i < 50005;i++){
							if(prim[i]){
								prime.add(i);
							}
						}
					}
					long[][] multiply(long[][] arr1,long[][] arr2){
						long[][] temp = new long[3][3];
						for(int i = 0;i < 3;i++){
							for(int j = 0;j < 3;j++){
								temp[i][j] = 0;
								for(int k = 0;k < 3;k++){
									temp[i][j] = (temp[i][j] + (arr1[i][k] * arr2[k][j])%MAX)%MAX;
								}
							}
						}
						return temp;
					}
					long power(long n){
						long[][] a = {{1,1,1},{1,0,0},{0,1,0}};
						long[][] result = {{1,0,0},{0,1,0},{0,0,1}};
						while(n > 0){
							if(n % 2 != 0){
								result = multiply(result,a);
							}
							a = multiply(a,a);
							n = n/2;
						}
						return ((7*result[0][0])%MAX + (4*result[0][1])%MAX + (2*result[0][2])%MAX)%MAX;
					}
					static class Pair implements Comparable<Pair>{
						int a;
						int b;
						Pair(int a,int b)	{
							this.a = a;
							this.b = b;
						}
						public boolean equals(Object o)
						{
							Pair p = (Pair)o;
							return p.a==a && p.b==b;
						}
						public int compareTo(Pair p){
							return Long.compare(this.a,p.a);
						}
						public int hashCode()
						{
							return new Long(a).hashCode()*31 + new Long(a).hashCode();
						}
					}
				}