import java.io.*;
import java.util.*;
import java.awt.geom.*;

/**
 * Solution to Shuffle
 * 
 * Consider a deck of n cards, ordered 1, 2, 3, ..., n. 
 * That's a single sequence, 1..n.
 * 
 * Split the deck at some point k, 1<=k<n. Then, interlace the two stacks.
 * That would give you a deck with two interlaced sequences: 1..k, and k+1..n.
 * Shuffle again - now, the deck will have 4 interlaced sequences.
 * Shuffle again - now, the deck will have 8 interlaced sequences.
 * So, the solution is to count the number of sequences in the deck (call it x),
 * and then find the smallest value y such that 2^y>=x.
 * 
 * Counting the sequences can be done in O(n). Here's how:
 * Every time we see a card, we should, some time later, expect to see the next card in order.
 * If a card is unexpected, then it must be the start of a new sequence.
 * 
 * Maintain a boolean array called "expected[]". Start with it all false.
 * Go through the deck, in order. For every card, if expected[card] is false, 
 * increment the number of sequences.
 * Then, in any case, set expected[card+1] to true.
 * 
 * @author vanb
 */
public class shuffles_vanb
{
    public Scanner sc;
    public PrintStream ps;
           
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out; 
                
        int n = sc.nextInt();
        boolean expected[] = new boolean[n+2];
        Arrays.fill( expected, false );
        
        // Count the number of sequences
        int nsequences = 0;
        for( int i=0; i<n; i++ )
        {
            int card = sc.nextInt();
            
            // Unexpected? Then it's the start of a new sequence.
            if( !expected[card] ) ++nsequences;
            
            // Now, we expect the next card.
            expected[card+1] = true;
        }
        
        // Find the smallest nshuffles such that 2^nshuffles >= nsequences
        // That's our answer. Since n<=1,000,000 then nshuffles<=20
        int nshuffles = 0;
        while( (1<<nshuffles)<nsequences ) ++nshuffles;
        ps.println( nshuffles );
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new shuffles_vanb().doit();
    }   
}