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

/**
 * Juggler
 * @author vanb
 *
 * This problem would be simple, except for the size of the numbers.
 * 
 * Put all of the balls into an array.
 * Look at the first drop. That's easy - it's just some arithmetic on the indices.
 * Look at the second - that's the same, except you've got to account for the 
 * first ball dropped. And the third? That's the same, except that you've got to
 * account for the first AND second balls dropped. That's adding up to an O(n^2)
 * algorithm and that's too much.
 * 
 * Suppose we were to rearrange the balls? Suppose we were to take all of the remaining
 * balls and move them to the head of the array? Then, we're back to just arithmetic
 * on the indices. The problem is that reordering the array is itself an O(n) operation.
 * If we do that n times, we're back to O(n^2).
 * 
 * So, suppose we only rearrange the balls sometimes? for instance, suppose we do it
 * every, oh, say, sqrt(n) ball drops?
 * 
 * So, our algorithm resets every sqrt(n) ball drops. Each pass between reordering is
 * O(sqrt(n)^2) (which is O(n))), and we do it sqrt(n) times, so that comes out to
 * O(n*sqrt(n)). Now, what about the reordering? That's O(n), and we do it sqrt(n) times,
 * so that, too, comes out to be O(n*sqrt(n)). So, the whole algorithm comes in at O(n*sqrt(n)).
 */
public class juggler
{
    public Scanner sc;
    public PrintStream ps;
    
    /**
     * Do it!
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "juggler.in" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "juggler.out" ) );
        
        // Allocate tables beforehand
        int ballat[] = new int[100000];
        int indexof[] = new int[100000];
        int idropped[] = new int[100000];
        
        for(;;)
        {
            int n = sc.nextInt();
            if( n==0 ) break;
            
            // Populate ballat[] and indexof[]
            // ballat[i] is the ball at index i
            // indexof[b] is the index of ball b
            for( int i=0; i<n; i++ )
            {
                int b = sc.nextInt()-1;
                ballat[i] = b;
                indexof[b] = i;
            }
            
            // This is going to be our final answer.
            // e'll start out with the n operations for dropping the n balls.
            long total = n;
            
            // This is the index of the ball currently in hand
            int inhand = 0;
            
            // This is the number of balls remaining. 
            // This only changes when we reorder the arrays.
            int remaining = n;
            
            // This is the number of balls dropped so far in this pass
            // between reorderings.
            int ndropped = 0;
            
            // This is our threshold for recomputing ballat[] and indexof[]
            int sqrt = n>99 ? (int)Math.sqrt( n ) : 100;
            
            // Loop through all of the balls, in order
            for( int b=0; b<n; b++ )
            {             
                // Index of the ball to be dropped
                int i = indexof[b];
               
                // The number of steps necessary, rotating left & right
                int left = (i-inhand+remaining ) % remaining;
                int right = remaining-left;             
                
                // This is the position of the ball to be dropped
                // relative to the ball in hand
                int ballrelative = left;
                                
                // Go through all of the balls that have already been dropped
                for( int k=0; k<ndropped; k++ )
                {
                    // The location of the previously dropped ball
                    // relative to the ball in hand
                    int droprelative = (idropped[k]-inhand+remaining) % remaining;
                    
                    // Is this dropped ball on the left side
                    // of the next ball, or the right?
                    if( droprelative<ballrelative ) --left; else --right;   
                }
                
                // Take the shorter of the two options
                total += Math.min( left, right );    
                             
                // Mark this ball as having been dropped
                ballat[i] = -1;
                
                // Record the drop
                idropped[ndropped++] = i;
                
                // Figure out which ball is now in hand. Look
                // for the next ball clockwise that hasn't been dropped.
                // Don't do this for the final ball. Since they've all
                // been dropped, that would be an infinite loop.
                inhand = i; 
                if(b<n-1) while( ballat[inhand]<0 ) inhand = (inhand+1)%remaining;
                
                // If it's time, rebuild ballat[] and indexof[]
                if( (b+1)%sqrt == 0 )
                {
                    // An index into the ballat[] array
                    int j=0;
                    
                    // Go through all of the remaining balls,
                    // and move any that haven't been dropped
                    // to the head of the list.
                    for( int k=0; k<remaining; k++ )
                    {
                        if( ballat[k]>0 )
                        {
                            if( inhand==k ) inhand = j;
                            ballat[j] = ballat[k];
                            indexof[ballat[j]] = j++;
                        }
                    }
                    
                    // Reset
                    ndropped = 0;
                    remaining -= sqrt;
                }
            }
            ps.println( total );            
        }
        
    }
    
    /**
     * Main
     * @param args Unused
     * @throws Exception
     */
    public static void main( String[] args ) throws Exception
    {
        new juggler().doit();
    }
}