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

/**
 * Solution to Beautiful Mountains
 * 
 * Stack blocks a prime distance apart. ALL stacks must be a prime distance
 * from ALL other stacks, NOT just adjacent stacks! 
 * 
 * Well, there are only 6 possibilities:
 * Case 1: All the blocks are in a single stack
 * Case 2: The blocks are in exactl3 2 stacks, 2 apart.
 * Case P: The blocks are in exactly 2 stacks, a prime number P distance apart, P>2.
 * Case 2P: The blocks are in three stacks: the first two 2 apart, and the last one a prime distance from there,
 *          where prime+2 is also prime.
 * Case P2: The blocks are in three stacks: the first a prime apart, and the last one 2 from there,
 *          where prime+2 is also prime.
 * Case 2P2: The blocks are in four stacks, distance 2, then a prime, then 2,
 *           where prime+2 and prime+4 are also prime.
 *           
 * There can't be any other combos. Consider P1>2 and P2>2, both prime. 
 * Then P1 and P2 are both odd, so P1+P2 is even, and thus not prime.
 * 
 * @author vanb
 */
public class mountains_vanb
{
    public Scanner sc;
    public PrintStream ps;
            
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in ); //new File( "mountains.judge" ) );
        ps = System.out; //new PrintStream( new FileOutputStream( "mountains.vanb" ) );
        
        // List of primes
        int primes[] = new int[30000];
        // Number of primes
        int np = 0;

        // Use the Sieve of Eratosthenes to get primes
        boolean isprime[] = new boolean[31000];
        Arrays.fill( isprime, true );
        isprime[0] = false;
        isprime[1] = false;
        for( int i=2; i<isprime.length; i++ ) if( isprime[i] )
        {
            primes[np++] = i;
            for( int j=i+i; j<isprime.length; j+=i)
            {
                isprime[j] = false;
            }
        }
                
        // The height of the stacks in the input
        int mountains[] = new int[30001];
        
        // sums[i] is the sum of mountains[0]..mountains[i]
        long sums[] = new long[30001];
        
        // leftcosts[i] is the cost to move all of the blocks left of i (<i) to i
        long leftcosts[] = new long[30001];
        
        // rightcosts[i] is the cost to move all of the blocks right of i (>i) to i
        long rightcosts[] = new long[30001];
        
        for(;;)
        {
            int n = sc.nextInt();
            if( n==0 ) break;
            
            // Compute mountains, sums, leftcosts
            mountains[0] = sc.nextInt();
            sums[0] = mountains[0];
            leftcosts[0] = 0;
            for( int i=1; i<n; i++ )
            {
                mountains[i] = sc.nextInt();
                sums[i] = sums[i-1] + mountains[i];
                leftcosts[i] = leftcosts[i-1] + sums[i-1];
            }
            
            // Start from the right end to compute rightcosts
            rightcosts[n-1] = 0;
            for( int i=n-2; i>=0; i-- )
            {
                rightcosts[i] = rightcosts[i+1] + sums[n-1] - sums[i];
            }
                                    
            long best = Long.MAX_VALUE;
            
            for( int i=0; i<n; i++ )
            {
                // Case 1
                long cost1 = leftcosts[i] + rightcosts[i];
                if( cost1<best ) best = cost1;
                
                if( i<n-2 )
                {
                    // Case 2
                    long cost2 = leftcosts[i] + mountains[i+1] + rightcosts[i+2];
                    if( cost2<best ) best = cost2;
                }
                
                // Look for prime diffs >2
                for( int j=1; primes[j]<n-i; j++ ) 
                {
                    int p = primes[j];
                    
                    // Case P
                    // This is the total cost to move all blocks outside of the P interval
                    long costP = leftcosts[i] + rightcosts[i+p];
                    
                    // Inside the P interval, we want to split it in half,
                    // and move the left half to the left pile, and the right half
                    // to the right pile.
                    int mid = p/2;
                    
                    // This the cost to move the left half of the pile,
                    // which are all to the right of the lower border
                    long rightmove = rightcosts[i] - rightcosts[i+mid+1] - (mid+1)*(sums[n-1] - sums[i+mid]);
                    
                    // This the cost to move the right half of the pile,
                    // which are all to the left of the upper border
                    long leftmove = leftcosts[i+p] - leftcosts[i+mid] - (mid+1)*sums[i+mid];
                    costP += rightmove;
                    costP += leftmove;
                    if( costP<best ) best = costP;
                                        
                    if( i>1 && isprime[p+2] )
                    {
                        // Case 2P
                        long cost2P = costP - leftcosts[i] + leftcosts[i-2] + mountains[i-1];
                        if( cost2P<best ) best = cost2P;                        
                    }
                    if( i+p<n-2 && isprime[p+2] )
                    {
                        // Case P2
                        long costP2 = costP - rightcosts[i+p] + rightcosts[i+p+2] + mountains[i+p+1];
                        if( costP2<best ) best = costP2;                        
                    }
                    if( i>1 && i+p<n-2 && isprime[p+2] && isprime[p+4] )
                    {
                        // Case 2P2
                        long cost2P2 = costP - leftcosts[i] + leftcosts[i-2] + mountains[i-1]
                                             - rightcosts[i+p] + rightcosts[i+p+2] + mountains[i+p+1];
                        if( cost2P2<best ) best = cost2P2;                        
                    }                    
                }
            }
            
            ps.println( best );
        }
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new mountains_vanb().doit();        
    }   
}