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

/**
 * Solution to Primal Partitions
 * 
 * @author vanb
 */
public class primal_fast_vanb
{
    public Scanner sc;
    public PrintStream ps;
    
    /** This is an array of all of the primes <1000 */
    public static int primes[] = new int[168];
    
    /**
     * Generate all of the primes <1000
     */
    public static void generatePrimes()
    {
        boolean isprime[] = new boolean[1001];
        Arrays.fill( isprime, true );
        isprime[0] = false;
        isprime[1] = false;
        int index = 0;
        for( int i=0; i<isprime.length; i++ ) if( isprime[i] )
        {
            primes[index++] = i;
            for( int j=i+i; j<isprime.length; j+=i ) isprime[j] = false;
        }
    }
    
    public int gcd( int a, int b )
    {
        return b==0 ? a : gcd( b, a%b );
    }
        
    /**
     * Driver.
     * @throws Exception
     */
    public void doit() throws Exception
    {
        sc = new Scanner( System.in );
        ps = System.out;
        
        generatePrimes();
        
        int biggestprime[] = new int[1000001];
        biggestprime[0] = biggestprime[1] = 0;
        for( int i=2; i<biggestprime.length; i++ )
        {
            int value = i;
            for( int j=0; j<primes.length && value>1; j++ )
            {
                int p = primes[j];
                if( value%p==0 ) 
                {
                    biggestprime[i] = p;
                    while( value%p==0 ) value /= p;
                }
            }
            
            if( value>1 ) biggestprime[i] = i;
        }
                
        int n = sc.nextInt();
        int k = sc.nextInt();
        
        int sequence[] = new int[n];
        for( int i=0; i<n; i++ )
        {
            int value = sequence[i] = sc.nextInt();
        }
        
        int smallest[][] = new int[n][k+1];
        int sets[][] = new int[n][k+1];
        Arrays.fill( smallest[0], 0 );
        Arrays.fill( sets[0], 0 );
        smallest[0][1] = biggestprime[sequence[0]];
        sets[0][1] = sequence[0];
                
        for( int i=1; i<n; i++ )
        {
            for( int j=1; j<=k; j++ )
            {
                int bestset = 0;
                int bestscore = 0;
                
                if( sets[i-1][j]>0 )
                {
                    bestset = gcd( sets[i-1][j], sequence[i] ); 
                    bestscore = Math.min( smallest[i-1][j], biggestprime[bestset] );
                }

                if( sets[i-1][j-1]>0 )
                {
                    int score = Math.min( smallest[i-1][j-1], biggestprime[sequence[i]] );
                    if( score > bestscore || bestset==0 )
                    {
                        bestscore = score;
                        bestset = sequence[i];
                    }
                }
                
                //if( bestscore==31 ) System.err.println( i + " " + j  );
                smallest[i][j] = bestscore;
                sets[i][j] = bestset;
            }            
        }
        ps.println( smallest[n-1][k] );
    }
    
    /**
     * @param args
     */
    public static void main( String[] args ) throws Exception
    {
        new primal_fast_vanb().doit();
    }   
}