Luba thinks about watering her garden. The garden can be represented as a segment of length k. Luba has got n buckets, the i-th bucket allows her to water some continuous subsegment of garden of length exactly ai each hour. Luba can't water any parts of the garden that were already watered, also she can't water the ground outside the garden.

Luba has to choose one of the buckets in order to water the garden as fast as possible (as mentioned above, each hour she will water some continuous subsegment of length ai if she chooses the i-th bucket). Help her to determine the minimum number of hours she has to spend watering the garden. It is guaranteed that Luba can always choose a bucket so it is possible water the garden.

See the examples for better understanding.

Input

The first line of input contains two integer numbers n and k (1 ≤ n, k ≤ 100) — the number of buckets and the length of the garden, respectively.

The second line of input contains n integer numbers ai (1 ≤ ai ≤ 100) — the length of the segment that can be watered by the i-th bucket in one hour.

It is guaranteed that there is at least one bucket such that it is possible to water the garden in integer number of hours using only this bucket.

Output

Print one integer number — the minimum number of hours required to water the garden.

Examples

Input

3 6
2 3 5


Output

2


Input

6 7
1 2 3 4 5 6


Output

7

Note

In the first test the best option is to choose the bucket that allows to water the segment of length 3. We can't choose the bucket that allows to water the segment of length 5 because then we can't water the whole garden.

In the second test we can choose only the bucket that allows us to water the segment of length 1.
import java.io.*;
	import java.math.BigInteger;
	import java.math.RoundingMode;
	import java.text.DecimalFormat;
	import java.util.*;
	
	
	public class Solution
	{
	
		static double eps=(double)1e-6;
		static long mod=(long)(1e9+7);
		//static int arr[] =new int[1000001];
		//private static DecimalFormat df2 = new DecimalFormat(".##");
		public static void main(String args[]){
			InputReader sc = new InputReader(System.in);
			//Scanner sc=new Scanner(System.in);
			OutputStream outputStream = System.out;
			PrintWriter out = new PrintWriter(outputStream);
			//----------my code----------
			int t1=1;
			while(t1-->0)
			{
				int n=sc.nextInt();
				int k=sc.nextInt();
				int min=Integer.MAX_VALUE;
				for(int i=0;i<n;i++)
				{
					int temp=sc.nextInt();
					if(k%temp==0)
					{
						min=Math.min(min,k/temp);
					}
				}
				out.println(min);
			}
			//---------------------------------
			out.close();
		}
		static class Pa {
			long x=0;
			long y=0;
			/*Pair(int xx,int yy,int zz){
				x=xx;
				y=yy;
				z=zz;
			}*/
			public long getx()
			{
				return x;
			}
			public long gety()
			{
				return y;
			}
			public void setx(long xx)
			{
				x=xx;
			}
			public void sety(long yy)
			{
				y=yy;
			}
		}
		static int curr_color(int arr[],int i,int curr[])
		{
			if(curr[i]!=0)
				return curr[i];
			return curr_color(arr,arr[i],curr);
		}
		
		static long modInverse(long A,long M)
		{
		    return modularExpon(A,M-2,M);
		}
		
		static long comb(int n,int r,long [][] c)
		{
			if(n<r)
				return 0;
			if(n-r < r) 
			{
				c[n][r]=comb(n,n-r,c);
				return c[n][r];
			}
		    if(r == 0)
		    {
		    	c[n][r]=1;
		    	return 1;
		   	}
		    if(c[n][r]!=0)
		    	return c[n][r];
		    else
		    {
		    	c[n][r]=(n*comb(n-1, r-1,c))/r;
		    	return c[n][r];
		    }
		}
		
		static long modularExpon(long x,long n,long M)
		{
		    long result=1;
		    while(n>0)
		    {
		        if(n % 2 ==1)
		            result=(result * x)%M;
		        x=(x*x)%M;
		        n=n/2;
		    }
		    return result%M;
		}
		
		static int IsPandigital(int n)
	    {
	        int digits = 0,temp=n; int count = 0; int tmp = 0;
	        int fr[]=new int[10];
	        for(int i=0;i<10;i++)
	        	fr[i]=0;
	        while(temp>0)
	        {
	        	int a=temp/10;
	        	//System.out.println(temp-a*10);
	        	fr[temp-a*10]++;
	        	temp=temp/10;
	        	digits++;
	        }
	        for(int i=1;i<=digits;i++)
	        {
	        	if(fr[i]==1)
	        	{
	        		tmp=1;
	        	}
	        	else
	        	{
	        		tmp=0;
	        		break;
	        	}
	        }
	        return tmp;
	    }
		
		static int Divisors(int n)
		{
			int sum=0;
		    for (int i=2; i*i<=n; i++)
		    {
		        if (n%i==0)
		        {
		            if (n/i == i)
		                {sum+=i;//System.out.println(sum+" "+i);
		                }
		 
		            else 
		                {sum+=i+(n/i);//System.out.println(sum+" "+i+" "+(n/i));
		                }
		        }
		    }
		    return sum;
		}
		
		static int findmax(int arr[], int n)
	    {
	        int incl = arr[0];
	        int excl = 0;
	        int excl_new;
	        int i;
	 
	        for (i = 1; i < n; i++)
	        {
	            excl_new = (incl > excl) ? incl : excl;
	            incl = excl + arr[i];
	            excl = excl_new;
	        }
	        return ((incl > excl) ? incl : excl);
	    }
		
		static long ce(long x)
		{
			if(x%2!=0)
				return x/2+1;
			return x/2;
		}
		static boolean isSubSequence(String str1, String str2, int m, int n)
		{
		   int j = 0;
		   for (int i=0; i<n&&j<m; i++)
		       if (str1.charAt(j) == str2.charAt(i))
		         j++;
		 
		   return (j==m);
		}
		
		static long fibo(long l) {
	        if (l < 0) {
	            throw new IllegalArgumentException("The fibo value cannot be negative");
	        }
	
	        if (l <= 1) return l;
	
	        long[][] result = {{1, 0}, {0, 1}}; // identity matrix.
	        long[][] fiboM = {{1, 1}, {1, 0}};
	
	        while (l > 0) {
	            if (l%2 == 1) {
	                multMatrix(result, fiboM);
	            }
	            l = l / 2;
	            multMatrix(fiboM, fiboM);
	        }
	
	        return result[1][0];
	    }
	
	    private static void multMatrix(long[][] result, long[][] fiboM) {
	        long a = (result[0][0]%mod * fiboM[0][0]%mod)%mod +  (result[0][1]%mod * fiboM[1][0]%mod)%mod;
	        long b = (result[0][0]%mod * fiboM[0][1]%mod)%mod + ( result[0][1]%mod * fiboM[1][1]%mod)%mod;
	        long c = (result[1][0]%mod * fiboM[0][0]%mod)%mod + ( result[1][1]%mod * fiboM[0][1]%mod)%mod;
	        long d = (result[1][0]%mod * fiboM[0][1]%mod)%mod +  (result[1][1]%mod * fiboM[1][1]%mod)%mod;
	
	        result[0][0] = a;
	        result[0][1] = b;
	        result[1][0] = c;
	        result[1][1] = d;
	    }
	    
	    static HashSet<Long> gr(int size)
	    {
	    	long range=mod;
	    	long m0=2017;
	    	long m1=2027;
	    	long ln=0;
	    	long sln=1;
	    	long mn=0;
	    	HashSet<Long> hs=new HashSet<Long>();
	    	for(int i=0;i<size;i++)
	    	{
	    		long nn=((((ln%mod)*m0)%mod+((sln%mod)*m1)%mod+mn)%mod)+1;
	    		sln=ln;
	    		ln=nn;
	    		mn=Math.max(mn, nn);
	    		hs.add(nn);
	    	}
	    	return hs;
	    }
	    
		static int[] sieve(int n,int[] a)
		{
			a[0]=1;
			a[1]=1;
			for(int i=2;i*i<=n;i++)
			{
				if(a[i]==0)
				{
					for(int j=i*2;j<=n;j+=i)
						a[j]=1;
				}
			}
			return a;
		}
		
		static int[] spfsieve(int arr[])
		{
			int n=5000000;
			arr[0]=1;
			arr[1]=1;
			for(int i=2;i<=n;i++)
				arr[i]=i;
			for(int i=4;i<=n;i+=2)
				arr[i]=2;
			for(int i=3;i*i<=n;i++)
			{
				if(arr[i]==i)
				{
					for(int j=i*i;j<=n;j+=i)
						if (arr[j]==j)
		                    arr[j] = i;
				}
			}
			return arr;
		}
		
		static boolean isPal(String s)
		{
			for(int i=0, j=s.length()-1;i<=j;i++,j--)
			{
				if(s.charAt(i)!=s.charAt(j)) return false;
			}
			return true;
		}
		public static String rev(String s)
		{
			StringBuilder sb=new StringBuilder(s);
			sb.reverse();
			return sb.toString();
		}
		    
		static long lcm(long a, long b)
		{
			long temp1=a,temp2=b;
		    return ((a * b) / gcd(temp1, temp2));
		}
		
		static long gcd(long a, long b)
		{
		    if (b==0)
		        return a;
		    return gcd(b, a%b);
		}
		static long modulo(long a,long b,long c) {
			long x=1;
			long y=a;
			while(b > 0){
				if(b%2 == 1){
					x=(x*y)%c;
				}
				y = (y*y)%c; // squaring the base
				b /= 2;
			}
			return  x%c;
		}
		public static void debug(Object... o) {
			System.out.println(Arrays.deepToString(o));
		}
		
		static class SegmentTree 
		{
		    long st[]; 
		    public SegmentTree(long arr[], int n)
		    {
		        int x = (int) (Math.ceil(Math.log(n) / Math.log(2)));
		 
		        int max_size = 2 * (int) Math.pow(2, x) - 1;
		 
		        st = new long[max_size];
		 
		        constructSTUtil(arr, 0, n - 1, 0);
		    }
		    int getMid(int s, int e) {
		        return s + (e - s) / 2;
		    }
		 
		    long getSumUtil(int ss, int se, int qs, int qe, int si)
		    {
		        if (qs <= ss && qe >= se)
		            return st[si];
		        if (se < qs || ss > qe)
		            return 0;
		        int mid = getMid(ss, se);
		        return getSumUtil(ss, mid, qs, qe, 2 * si + 1) +
		                getSumUtil(mid + 1, se, qs, qe, 2 * si + 2);
		    }
		 
		    void updateValueUtil(int ss, int se, int i, int diff, int si)
		    {
		        if (i < ss || i > se)
		            return;
		        st[si] = st[si] + diff;
		        if (se != ss) {
		            int mid = getMid(ss, se);
		            updateValueUtil(ss, mid, i, diff, 2 * si + 1);
		            updateValueUtil(mid + 1, se, i, diff, 2 * si + 2);
		        }
		    }
		 
		    void updateValue(int arr[], int n, int i, int new_val)
		    {
		        if (i < 0 || i > n - 1) {
		            System.out.println("Invalid Input");
		            return;
		        }
		 
		        // Get the difference between new value and old value
		        int diff = new_val - arr[i];
		 
		        // Update the value in array
		        arr[i] = new_val;
		 
		        // Update the values of nodes in segment tree
		        updateValueUtil(0, n - 1, i, diff, 0);
		    }
		    long getSum(int n, int qs, int qe)
		    {
		        if (qs < 0 || qe > n - 1 || qs > qe) {
		            System.out.println("Invalid Input");
		            return -1;
		        }
		        return getSumUtil(0, n - 1, qs, qe, 0);
		    }
		 
		    long constructSTUtil(long arr[], int ss, int se, int si)
		    {
		        if (ss == se) {
		            st[si] = arr[ss];
		            return arr[ss];
		        }
		        int mid = getMid(ss, se);
		        st[si] = constructSTUtil(arr, ss, mid, si * 2 + 1) +
		                 constructSTUtil(arr, mid + 1, se, si * 2 + 2);
		        return st[si];
		    }
		}
		static class Pair {
			long x=0;
			long y=0;
			long z=0;
			/*Pair(int xx,int yy,int zz){
				x=xx;
				y=yy;
				z=zz;
			}*/
			public long getx()
			{
				return x;
			}
			public long gety()
			{
				return y;
			}
			public long getz()
			{
				return z;
			}
			
			public void setz(long zz)
			{
				z=zz;
			}
			public void setx(long xx)
			{
				x=xx;
			}
			public void sety(long yy)
			{
				y=yy;
			}
		}
		
		public final static Comparator<Pair> ORIGINAL = new Comparator<Pair>()
	    {
		public int compare(Pair p1,Pair p2)
		{
			if(p1.gety()<p2.gety())
				return -1;
			else if(p1.gety()==p2.gety() && p2.getx()<p1.getx())
				return -1;
			else //if(p1.getx()>p2.getx() || p1.gety()>p2.gety() || p1.getz()>p2.getz())
				return 1;
			/*else
			{
				if(p1.gety()<p2.gety())
					return -1;
				else if(p1.gety()>p2.gety())
					return 1;
				else
				{
					if(p1.getz()<p2.getz())
						return -1;
					else if(p1.getz()>p2.getz())
						return 1;
				}
			}*/
			//return 0;
		}
	    };
		
		static class InputReader {
			public BufferedReader reader;
			public StringTokenizer tokenizer;
	
			public InputReader(InputStream inputstream) {
				reader = new BufferedReader(new InputStreamReader(inputstream));
				tokenizer = null;
			}
	
			public String nextLine(){
				String fullLine=null;
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					try {
						fullLine=reader.readLine();
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
					return fullLine;
				}
				return fullLine;
			}
			public String next() {
				while (tokenizer == null || !tokenizer.hasMoreTokens()) {
					try {
						tokenizer = new StringTokenizer(reader.readLine());
					} catch (IOException e) {
						throw new RuntimeException(e);
					}
				}
				return tokenizer.nextToken();
			}
			public long nextLong() {
				return Long.parseLong(next());
			}
			public int nextInt() {
				return Integer.parseInt(next());
			}
		}
		
	}
	class Graph
	{
		int vertices;
		LinkedList<Integer> l[];
		Graph(int vertices)
		{
			this.vertices=vertices;
			l=new LinkedList[vertices];
			for(int i=0;i<vertices;i++)
			{
				l[i]=new LinkedList<Integer>();
			}
		}	
		void addEdge(int s,int v)
		{
			l[s].add(v);
		}
		
		void BFS(int s)
		{
			LinkedList<Integer> queue=new LinkedList<Integer>();
			boolean []visited=new boolean[vertices];
			visited[s]=true;
			queue.add(s);
			while(queue.size()>0)
			{
				int r=queue.poll();
				System.out.println(r+" ");
				for(int i=0;i<l[r].size();i++)
				{
					int temp=l[r].get(i);
					if(!visited[temp])
					{
						queue.add(temp);
						visited[temp]=true;
					}
				}
			}
		}
		
	}  