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.util.*;
import java.io.*;
import java.util.Queue;
import java.util.LinkedList;
import java.math.*;
 
     public class Sample implements Runnable
    { 
        
         
            
          public  static void solve()
          {  
            
              int n=i(); int k=i();
              int ans=Integer.MAX_VALUE;
              for(int i=0;i<n;i++)
              {
                int data=i();
                if(k%data==0)
                {
                  ans=Math.min(ans,k/data);
                }
              }
              out.println(ans);
                 
          }
           
            
          public void run()
          {   
              solve();
              out.close();
          }
 
          public static void main(String[] args) throws IOException
          { 
                new Thread(null, new Sample(), "whatever", 1<<26).start();
          }
         abstract static class Pair implements Comparable<Pair>
         {
            long a;
            int b;
            
            Pair(){}
            Pair(long a,int b)
            {
                       this.a=a;
                       this.b=b;
            }
   
            public int compareTo(Pair x)
           {
                return Long.compare(x.a,this.a);
           }
        }
        
       
         
    ////////////////////////////////////////////////////// Merge Sort ////////////////////////////////////////////////////////////////////////
     
   static class Merge 
   {
 
        public static void sort(long inputArr[]) 
        {
            int length = inputArr.length;
            doMergeSort(inputArr,0, length - 1);
        }
 
        private static void doMergeSort(long[] arr,int lowerIndex, int higherIndex) 
        {        
            if (lowerIndex < higherIndex) {
                int middle = lowerIndex + (higherIndex - lowerIndex) / 2;
                doMergeSort(arr,lowerIndex, middle);
                doMergeSort(arr,middle + 1, higherIndex);
                mergeParts(arr,lowerIndex, middle, higherIndex);
            }
        }
 
        private static void mergeParts(long[]array,int lowerIndex, int middle, int higherIndex) 
        {
            long[] temp=new long[higherIndex-lowerIndex+1];
            for (int i = lowerIndex; i <= higherIndex; i++) 
            {
                temp[i-lowerIndex] = array[i];
            }
            int i = lowerIndex;
            int j = middle + 1;
            int k = lowerIndex;
            while (i <= middle && j <= higherIndex) 
            {
                if (temp[i-lowerIndex] < temp[j-lowerIndex]) 
                {
                    array[k] = temp[i-lowerIndex];
                    i++;
                } else {
                    array[k] = temp[j-lowerIndex];
                    j++;
                }
                k++;
            }
            while (i <= middle) 
            {
                array[k] = temp[i-lowerIndex];
                k++;
                i++;
            }
            while(j<=higherIndex)
            {
                array[k]=temp[j-lowerIndex];
                k++;
                j++;
            }
        }
 
    }
        
      
    /////////////////////////////////////////////////////////// Methods ////////////////////////////////////////////////////////////////////////
 
 
     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;
     }
     static String rev(String s)
     {
                StringBuilder sb=new StringBuilder(s);
                sb.reverse();
                return sb.toString();
     }
     static int gcd(int a,int b){return (a==0)?b:gcd(b%a,a);}
     static long gcdExtended(long a,long b,long[] x)
     {
 
        if(a==0){
            x[0]=0;
            x[1]=1;
            return b;
        }
        long[] y=new long[2];
        long gcd=gcdExtended(b%a, a, y);
 
        x[0]=y[1]-(b/a)*y[0];
        x[1]=y[0];
 
        return gcd;
    }
 
     boolean findSum(int set[], int n, long sum)
    {
      if (sum == 0)
         return true;
      if (n == 0 && sum != 0)
         return false;
      if (set[n-1] > sum)
         return findSum(set, n-1, sum);
      return findSum(set, n-1, sum) ||findSum(set, n-1, sum-set[n-1]);
    }
   
      public static long modPow(long base, long exp, long mod)
     {
        base = base % mod;
        long result = 1;
        while (exp > 0)
       {
            if (exp % 2 == 1) 
            {
                result = (result * base) % mod;
            }
            base = (base * base) % mod;
            exp = exp >> 1;
       }
        return result;
    }
 
    static long[] fac;
    static long[] inv;
    static long mod=(long)1e9+7;
    public static void cal() 
    {
        fac = new long[1000005];
        inv = new long[1000005];
        fac[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= 1000000; i++)
        {
            fac[i] = (fac[i - 1] * i) % mod;
            inv[i] = (inv[i - 1] * modPow(i, mod - 2, mod)) % mod;
        }
    }
 
    public static long ncr(int n, int r) 
    {
        return (((fac[n] * inv[r]) % mod) * inv[n - r]) % mod;
    }
 
 
////////////////////////////////////////// Input Reader ////////////////////////////////////////////////////////////////////////////////////////////////////
     
    static InputReader sc = new InputReader(System.in);
    static PrintWriter out= new PrintWriter(System.out);   
    
    static class InputReader {
 
          private final InputStream stream;
          private final byte[] buf = new byte[8192];
          private int curChar, snumChars;
          private SpaceCharFilter filter;
 
          public InputReader(InputStream stream) {
                  this.stream = stream;
          }
 
          public int snext()
         {
                  if (snumChars == -1)
                          throw new InputMismatchException();
                  if (curChar >= snumChars) {
                          curChar = 0;
                          try {
                                  snumChars = stream.read(buf);
                          } catch (IOException e) {
                                  throw new InputMismatchException();
                          }
                          if (snumChars <= 0)
                                  return -1;
                  }
                  return buf[curChar++];
          }
 
          public int nextInt()
         {
                  int c = snext();
                  while (isSpaceChar(c)) 
                  {
                          c = snext();
                  }
                  int sgn = 1;
                  if (c == '-')
                  {
                          sgn = -1;
                          c = snext();
                  }
                  int res = 0;
                  do {
                          if (c < '0' || c > '9')
                                  throw new InputMismatchException();
                          res *= 10;
                          res += c - '0';
                          c = snext();
                  } while (!isSpaceChar(c));
                  return res * sgn;
          }
 
          public long nextLong() 
          {
                  int c = snext();
                  while (isSpaceChar(c)) 
                  {
                          c = snext();
                  }
                  int sgn = 1;
                  if (c == '-') 
                  {
                          sgn = -1;
                          c = snext();
                  }
                  long res = 0;
                  do {
                          if (c < '0' || c > '9')
                                  throw new InputMismatchException();
                          res *= 10;
                          res += c - '0';
                          c = snext();
                  } while (!isSpaceChar(c));
                  return res * sgn;
          }
 
          public int[] nextIntArray(int n)
          {
                  int a[] = new int[n];
                  for (int i = 0; i < n; i++) 
                  {
                          a[i] = nextInt();
                  }
                  return a;
          }
 
          public long[] nextLongArray(int n)
          {
                  long a[] = new long[n];
                  for (int i = 0; i < n; i++) 
                  {
                          a[i] = nextLong();
                  }
                  return a;
          }
 
          
          public String nextLine()
         {
                  int c = snext();
                  while (isSpaceChar(c))
                          c = snext();
                  StringBuilder res = new StringBuilder();
                  do {
                          res.appendCodePoint(c);
                          c = snext();
                  } while (!isEndOfLine(c));
                  return res.toString();
          }
 
          public boolean isSpaceChar(int c) 
          {
                  if (filter != null)
                          return filter.isSpaceChar(c);
                  return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
 
          private boolean isEndOfLine(int c) 
          {
                  return c == '\n' || c == '\r' || c == -1;
          }
 
          public interface SpaceCharFilter 
          {
                  public boolean isSpaceChar(int ch);
          }
 
    }
 
    static int i()
    {
        return sc.nextInt();
    }
    static long l(){
        return sc.nextLong();
    }
    static int[] iarr(int n)
    {
        return sc.nextIntArray(n);
    }
    static long[] larr(int n)
    {
        return sc.nextLongArray(n);
    }
    static String s(){
        return sc.nextLine();
    }
  
 
 }  