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.IOException;
import java.io.InputStream;
import java.math.BigInteger;
import java.util.InputMismatchException;

public class Garden
{
    public static void main(String[] args)
    {
        int n, k, min = 1000;
        FastReader in = new FastReader(System.in);
        n = in.nextInt();
        k = in.nextInt();
        int[] arr = new int[n];

        for (int i = 0; i < n; i++)
        {
            arr[i] = in.nextInt();
            if (k % arr[i] == 0)
            {
                min = Math.min(min, k / arr[i]);
            }
        }

        System.out.println(min);
    }
}


class FastReader{
	private boolean finished = false;
 
	private InputStream stream;

	private byte[] buf = new byte[1024];
	private int curChar;
	private int numChars;
	private SpaceCharFilter filter;
 
	public FastReader(InputStream stream){
		this.stream = stream;
	}
 
	public int read(){
		if (numChars == -1){
			throw new InputMismatchException();
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				throw new InputMismatchException ();
			}
			if (numChars <= 0){
				return -1;
			}
		}
		return buf[curChar++];
	}
 
	public int peek(){
		if (numChars == -1){
			return -1;
		}
		if (curChar >= numChars){
			curChar = 0;
			try{
				numChars = stream.read (buf);
			} catch (IOException e){
				return -1;
			}
			if (numChars <= 0){
				return -1;
			}
		}
		return buf[curChar];
	}
 
	public int nextInt(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		int res = 0;
		do{
			if(c==','){
				c = read();
			}
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		} while (!isSpaceChar (c));
		return res * sgn;
	}
 
	public long nextLong(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		long res = 0;
		do{
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		} while (!isSpaceChar (c));
		return res * sgn;
	}
 
	public String nextString(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		StringBuilder res = new StringBuilder ();
		do{
			res.appendCodePoint (c);
			c = read ();
		} while (!isSpaceChar (c));
		return res.toString ();
	}
 
	public boolean isSpaceChar(int c){
		if (filter != null){
			return filter.isSpaceChar (c);
		}
		return isWhitespace (c);
	}
 
	public static boolean isWhitespace(int c){
		return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
	}
 
	private String readLine0(){
		StringBuilder buf = new StringBuilder ();
		int c = read ();
		while (c != '\n' && c != -1){
			if (c != '\r'){
				buf.appendCodePoint (c);
			}
			c = read ();
		}
		return buf.toString ();
	}
 
	public String nextLine(){
		String s = readLine0 ();
		while (s.trim ().length () == 0)
			s = readLine0 ();
		return s;
	}
 
	public String nextLine(boolean ignoreEmptyLines){
		if (ignoreEmptyLines){
			return nextLine ();
		}else{
			return readLine0 ();
		}
	}
 
	public BigInteger nextBigInteger(){
		try{
			return new BigInteger (nextString ());
		} catch (NumberFormatException e){
			throw new InputMismatchException ();
		}
	}
 
	public char nextCharacter(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		return (char) c;
	}
 
	public double nextDouble(){
		int c = read ();
		while (isSpaceChar (c))
			c = read ();
		int sgn = 1;
		if (c == '-'){
			sgn = -1;
			c = read ();
		}
		double res = 0;
		while (!isSpaceChar (c) && c != '.'){
			if (c == 'e' || c == 'E'){
				return res * Math.pow (10, nextInt ());
			}
			if (c < '0' || c > '9'){
				throw new InputMismatchException ();
			}
			res *= 10;
			res += c - '0';
			c = read ();
		}
		if (c == '.'){
			c = read ();
			double m = 1;
			while (!isSpaceChar (c)){
				if (c == 'e' || c == 'E'){
					return res * Math.pow (10, nextInt ());
				}
				if (c < '0' || c > '9'){
					throw new InputMismatchException ();
				}
				m /= 10;
				res += (c - '0') * m;
				c = read ();
			}
		}
		return res * sgn;
	}
 
	public boolean isExhausted(){
		int value;
		while (isSpaceChar (value = peek ()) && value != -1)
			read ();
		return value == -1;
	}
 
	public String next(){
		return nextString ();
	}
 
	public SpaceCharFilter getFilter(){
		return filter;
	}
 
	public void setFilter(SpaceCharFilter filter){
		this.filter = filter;
	}
 
	public interface SpaceCharFilter{
		public boolean isSpaceChar(int ch);
	}
}