3 7
3 2 1
 4 97
97 1 50 10
 5 25
24 5 15 25 23
 3 3
3 2 1
 4 18
3 1 1 2
 5 97
1 10 50 97 2
 1 88
1
 3 18
1 9 3
 8 8
8 7 6 5 4 3 2 1
 2 1
2 1
 5 16
8 4 2 1 7
 2 16
8 4
 1 25
25
 2 2
2 1
 4 21
21 20 21 2
 3 28
7 14 1
 2 6
3 2
 5 12
12 4 3 4 4
 5 10
5 4 3 2 1
 4 32
1 1 1 1
 5 12
2 3 12 6 4
 2 100
99 1
 3 6
1 3 2
 79 12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79
 3 6
6 3 2
 3 12
3 12 2
 5 97
1 10 50 100 2
 6 8
6 5 4 3 2 1
 7 24
1 3 6 4 5 2 7
 4 12
1 2 12 3
 5 12
12 4 4 4 3
 3 8
4 3 2
 2 4
4 1
 100 100
2 46 24 18 86 90 31 38 84 49 58 28 15 80 14 24 87 56 62 87 41 87 55 71 87 32 41 56 91 32 24 75 43 42 35 30 72 53 31 26 54 61 87 85 36 75 44 31 7 38 77 57 61 54 70 77 45 96 39 57 11 8 91 42 52 15 42 30 92 41 27 26 34 27 3 80 32 86 26 97 63 91 30 75 14 7 19 23 45 11 8 43 44 73 11 56 3 55 63 16
 3 9
3 2 1
 2 10
5 2
 2 4
8 1
 11 99
1 2 3 6 5 4 7 8 99 33 66
 4 12
1 4 3 2
 2 6
5 3
 4 6
3 2 5 12
 3 10
2 10 5
 2 12
4 3
 6 8
2 4 1 3 5 7
 6 15
5 2 3 6 4 3
 3 8
3 4 2
 99 12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99
 2 18
6 3
 4 12
6 4 3 1
 3 6
3 2 1
 4 6
6 1 2 3
 4 4
1 2 2 4
 3 8
7 2 4
 6 87
1 2 8 4 5 7
 3 6
10 2 3
 4 8
2 8 4 1
 5 6
3 2 4 2 2
 4 100
2 50 4 1
 100 91
13 13 62 96 74 47 81 46 78 21 20 42 4 73 25 30 76 74 58 28 25 52 42 48 74 40 82 9 25 29 17 22 46 64 57 95 81 39 47 86 40 95 97 35 31 98 45 98 47 78 52 63 58 14 89 97 17 95 28 22 20 36 68 38 95 16 2 26 54 47 42 31 31 81 21 21 65 40 82 53 60 71 75 33 96 98 6 22 95 12 5 48 18 27 58 62 5 96 36 75
 2 100
7 1
 4 12
1 3 4 2
 1 89
1
 3 18
1 9 6
 3 6
2 3 1
 3 6
5 3 2
 3 6
2 3 2
 5 6
2 3 5 1 2
 3 19
7 1 1
 3 12
1 12 2
 3 8
4 2 1
 4 12
1 2 4 3
 2 5
5 1
 6 7
6 5 4 3 7 1
 5 3
2 4 5 3 6
 3 8
2 4 2
 4 8
2 4 8 1
 98 12
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
 3 8
8 4 2
 3 6
3 2 5
 1 1
1
 1 100
1

7
 1
 1
 1
 6
 1
 88
 2
 1
 1
 2
 2
 1
 1
 1
 2
 2
 1
 2
 32
 1
 100
 2
 1
 1
 1
 97
 2
 4
 1
 1
 2
 1
 50
 3
 2
 4
 1
 3
 2
 2
 1
 3
 2
 3
 2
 1
 3
 2
 2
 1
 1
 2
 87
 2
 1
 2
 2
 7
 100
 3
 89
 2
 2
 2
 2
 2
 19
 1
 2
 3
 1
 1
 1
 2
 1
 1
 1
 2
 1
 100

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.ExecutionException;

import javax.management.Query;
import javax.swing.plaf.nimbus.NimbusLookAndFeel;

import java.util.PriorityQueue;
import java.util.Set;
import java.util.Stack;
import java.util.StringTokenizer;
import static java.lang.Integer.parseInt;
import static java.lang.Long.parseLong;
import static java.lang.Double.parseDouble;

public class Solution { 
 	static  int mod=1000000007;
 	static int count=1;
	public static void main(String[] args) throws IOException, InterruptedException {
		PrintWriter out=new PrintWriter(System.out); 
		BufferedReader br=new  BufferedReader(new InputStreamReader(System.in));
		StringTokenizer st;
	    //reviser complement 2
		//hexadecimal
	    st=new StringTokenizer(br.readLine());
	    int n=parseInt(st.nextToken());
	    int k=parseInt(st.nextToken());
	    int[] arr=new int[n];
	    st=new StringTokenizer(br.readLine());
	    int h_min=Integer.MAX_VALUE;
	    for(int i=0 ; i < n; ++i){
	    	arr[i]=parseInt(st.nextToken());
	    	if(k%arr[i] == 0 && k/arr[i] < h_min  ) h_min=k/arr[i];
	    }
	    out.println(h_min);
	    
	    
	    		
	    
			   
		
		
		
		out.close();
		
	
	
	
	
	}
	
	static void color(LinkedList<Integer>[] list,int[] color,  int parent){
		
		for(int i=0; i < list[parent].size(); ++i){
			if(color[parent] != color[list[parent].get(i)]){
				++count;
				//System.out.println(parent+":             "+list[parent].get(i));
			
			}
			try{
				color(list, color, list[parent].get(i));
			}catch(Exception e){
				System.out.println(parent+"    "+list[parent].get(i)+"   "+e.getMessage());
				
			}
			
			
		}	
		/*for(int i=0 ; i < list[child].size();++i){
			if(color[child] != color[list[child].get(i)]){
				System.out.println(child+":             "+list[child].get(i));
					color(list, color, list[child].get(i));
			}
		}*/
	}
	static boolean answer(int n){
		if(n < 0) return false;
		else if(n == 0) return true;
		return (answer(n - 3) || answer(n - 7));
		
	}
	static int[][] createMatrix(int n, int m){
		int[][] matrix=new int[n][m];
		for(int i=0 ; i < n   ;++i){
			for(int k = 0; k < m;++k){
				if(k==0 || k==1) matrix[i][k]=i*m + k+1;
				else if (i%2 == 0){
					int inter=matrix[i][k-2];
					matrix[i][k] = inter;
					matrix[i][k-2]=i*m + k+1;
				}else{
					matrix[i][k]=i*m + k+1;
				}
			}
		}
		
		
		for(int i = 1; i < n; i+=2){
			for(int k=0; k < m; k+=2){
				int inter=matrix[i][k];
				matrix[i][k]=matrix[i-1][k];
				matrix[i-1][k]=inter;
			}
		}
		return matrix;
	}
	static boolean nim_game(int n){
		int[] win_pos=new int[]{2, 3, 5, 4};
		if(n > 0){
			for(int x: win_pos){
				if(x == n) return true;
			}
			if(n == 1) return false;
			if(!nim_game(n - 5)|| !nim_game(n - 3)|| !nim_game(n - 2)) return true;
		}
		return false;
	}
	static int xor_range(int n){
		if(n == 0) return 0;
		int r= n% 4;
		if(r == 0) return n; 
		if(r == 1) return 1;
		if(r == 2) return n+1;
		return 0;
	}
	static void sol(int[] arr, int index, int time, int k, HashMap<Integer, Integer> map, int sum){
		if( time == k+1){ 
				if(map.containsKey(sum)) map.put(sum, map.get(sum) + 1);
				else map.put(sum, 1);
		}
		
		if(time <= k){
			for(int i=index ; i  < arr.length; ++i){
				sol(arr, i + 1 , time + 1 , k, map, sum + arr[i]);
			}
		}
	}
	
	static int combinaison(double n, double k){//c(n, k)= (k+1)/(n-k)
		double res= 1;
		for(int i= 1; i<=k; ++i){
			res *= (n-i+1)/(i);
		}
		return (int)res;
	}
	static int countmin(int a, int b, int c){
		//Given a sequence of three binary sequences A, B and C of N bits. Count the minimum bits
		//required to flip in A and B such that XOR of A and B is equal to C
		int res= a ^ b ^ c;
		int count=0;
		while(res != 0){
			++count;
			res&=res - 1;
		}
		return count;
	}
	static int countval(int n){//Given a positive integer n, find count of positive integers i such that 0 <= i <= n and n+i = n^i
		int count=0;
		while(n != 0){
			if((n & 1) == 0) ++count;
		}
		return 1<<count;
	}
	static int firstright(int x){
		
		int y=1;
		int pos=1;
		while((x&y) == 0){
			pos++;
			y<<=1;
		}
		return pos;
	}
	
	static int atob(int a, int b){
		int c= a^b;
		int count=0;
		while(c != 0){
			c&=(c-1);
			++count;
		}
		return count;
	}
	  
	
	static int setBits(int x){
		int count=0;
		if(x == 0) return 0;
		while(x != 0){
			if(x % 2 == 1){
				--x;
				++count;
			}
			x/=2;
			
		}
		return count;
	}
	static boolean isPower4(long x){
			if((x & (x-1)) != 0) return false;
			int count=0;
			while(x != 1){
				x>>=1;
				++count;
			}
			
			if(count % 2 == 0) return true;
			return false;
	
	}
	
	
	
	static long addOne(long x){// add one using bit manipulation
	    long y = 1; 
		while((x & y) != 0){
			x ^= y;
			y<<=1;
		}
		
		return x ^ y;
	}
	
	static int compute_xor_range(int n){// compute xor from 1 to n
		int r= n % 4;
		if(r== 0) return n;
		else if(r== 1) return 1;
		else if(r== 2) return n+1;
		else return 0;
				
	}
	
	static long number_combinaisons(long n){//n cardinal of set 
		//fonction return number of combinaisons
		return (1 << n) ;
	}
	
	static boolean isPoweroftwo(long x){
		//check a number is power of two 
		//we use x & (x-1) to eliminate the first set bit
		
		return (x!=0 && (x & (x-1)) == 0)?true:false;
	}
	
	static long findxor(long[] Set,long n){// this function find xor of xor's of all subsets
		//n is length of set array
		if(n >1 ) return 0;
		else return Set[0];
	}
	// pour generer un nombre entier a partir de binaire int a=0b111;
	
	static long MSB(long n){// most significant bit
		while((n&(n-1)) != 0){
			n &= n-1;
		}
		return n;
	}
	
	static long LSB(long n){
	      if(n == 0) return 0;
	      return n-(n & (n-1));
	}
	
	
	 
	
		
}




