There are n psychos standing in a line. Each psycho is assigned a unique integer from 1 to n. At each step every psycho who has an id greater than the psycho to his right (if exists) kills his right neighbor in the line. Note that a psycho might kill and get killed at the same step. 

You're given the initial arrangement of the psychos in the line. Calculate how many steps are needed to the moment of time such, that nobody kills his neighbor after that moment. Look notes to understand the statement more precise.

Input

The first line of input contains integer n denoting the number of psychos, (1 ≤ n ≤ 105). In the second line there will be a list of n space separated distinct integers each in range 1 to n, inclusive — ids of the psychos in the line from left to right.

Output

Print the number of steps, so that the line remains the same afterward.

Examples

Input

10
10 9 7 8 6 5 3 4 2 1


Output

2


Input

6
1 2 3 4 5 6


Output

0

Note

In the first sample line of the psychos transforms as follows: [10 9 7 8 6 5 3 4 2 1]  →  [10 8 4] →  [10]. So, there are two steps.
	                            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;
import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Stack;
	
	
	
	                                            public class Solution1 implements Runnable
	                                            {
	                                                static final long MAX = 464897L;
	                                                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(),"Solution",1<<26).start();
	                                                }    
	                                                public static int gcd(int a, int b)
	                                                {
	                                                    if (a == 0)
	                                                        return b;
	                                                     
	                                                    return gcd(b%a, a);
	                                                }
	                                                int lcm(int a, int b)
	                                                {
	                                                    return (a*b)/gcd(a, b);
	                                                }
	                                                ArrayList<Integer> adj[];
	                                                ArrayList<Integer> adj1[];
	                                                static long MOD = 1000000007;
	                                                int[] dx = {1,-1,0,0};
	                                                int[] dy = {0,0,1,-1};
	                                                int MAXN = 30000005;
	                                                long[] val;
	                                                public void run() 
	                                                {
	                                                    
	                                                        //InputReader sc= new InputReader(new FileInputStream("input.txt"));
	                                                        //PrintWriter w= new PrintWriter(new FileWriter("output.txt"));
	                                                        InputReader sc = new InputReader(System.in);
	                                                        PrintWriter w = new PrintWriter(System.out);
	                                                        int n = sc.nextInt();
	                                                        boolean[] alive=  new boolean[n];
	                                                        Arrays.fill(alive,false);
	                                                        long max = -1;
	                                                        int[] arr = new int[n];
	                                                        for(int i = 0;i < n;i++) {
	                                                        	arr[i] = sc.nextInt();
	                                                        }
	                                                        for(int i = 0;i < n;i++) {
	                                                        	if(max < arr[i]) {
	                                                        		max = arr[i];
	                                                        		alive[i] = true;
	                                                        	}
	                                                        }
	                                                        int cnt = 1;
	                                                        max = 0;
	                                                        PriorityQueue<Pair> pq = new PriorityQueue();
	                                                        long[] dp = new long[n];
	                                                        
	                                                        pq.add(new Pair(0,arr[0]));
	                                                        for(int i = 1;i < n;i++) {
	                                                        	long temp = 1;
	                                                        	if(arr[i] < arr[i-1]) {
	                                                        		max = Math.max(max, 1);
	                                                        	}
	                                                        	if(arr[i] > arr[i-1]) {
	                                                        		while(!pq.isEmpty()) {
	                                                        			Pair tmp = pq.peek();
	                                                        			if(tmp.b < arr[i]){
	                                                        				temp = Math.max(temp,dp[tmp.a]);
	                                                        				pq.poll();
	                                                        			}else {
	                                                        				break;
	                                                        			}
	                                                        		}
	                                                        		if(pq.isEmpty()) {
	                                                        			dp[i] = 100000000;
	                                                        			pq.add(new Pair(i,arr[i]));
	                                                        		}else {
	                                                        			dp[i] = temp + 1;
	                                                        		    max = Math.max(max,temp + 1);
	                                                        		    pq.add(new Pair(i,arr[i]));
 	                                                        		}
	                                                        	}
	                                                        }
	                                                        w.println(max);
	                                                        w.close();	                                                                                                                      
	                                                 }
	                                                boolean[] visited;
	                                                ArrayList<ArrayList<Integer>> ar = new ArrayList();
	                                                ArrayList<Integer> temp;
	                                                void dfs1(int a) {
	                                                	visited[a] = true;
	                                                	Iterator<Integer> it = adj1[a].iterator();
	                                                	while(it.hasNext()) {
	                                                		int x = it.next();
	                                                		if(!visited[x]) {
	                                                			dfs1(x);
	                                                		}
	                                                	}
	                                                	temp.add(a);
	                                                }
	                                                void topo() {
	                                                	for(int i = 0;i < adj.length;i++) {
	                                                		if(!visited[i]) {
	                                                			dfs(i);
	                                                		}
	                                                	}
	                                                }
	                                                Stack<Integer> st=  new Stack();
	                                                void dfs(int a) {
	                                                	visited[a] = true;
	                                                	Iterator<Integer> it = adj[a].iterator();
	                                                	while(it.hasNext()) {
	                                                		int x = it.next();
	                                                		if(!visited[x]) {
	                                                			dfs(x);
	                                                		}
	                                                	}
	                                                	st.add(a);
	                                                }
	                                                static class Pair implements Comparable<Pair>{
	                                                    int a;
	                                                    int b;
	                                                    
	                                                    
	                                                    Pair(int a,int b){
	                                                        this.a  =a;
	                                                        this.b = b;
	                                                        
	                                                    }
	                                                    Pair(){}    
	                                                    public boolean equals(Object o)
	                                                    {
	                                                        Pair p = (Pair)o;
	                                                        return (this.a == p.a && this.b == p.b) || (this.a == p.b && this.b == p.a);
	                                                    }
	                                                    
	                                                    public int compareTo(Pair p){
	                                                    	 return Integer.compare(this.b, p.b);
	                                                    }
	                                                    public int hashCode()
	                                                    {
	                                                        return new Long(a).hashCode()*31 + new Long(b).hashCode()*2 + new Long(a).hashCode() * 3;
	                                                    }
	
	                                                }
	                                                
	                                }