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 a_{i} 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 a_{i} 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 a_{i} (1 ≤ a_{i} ≤ 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.

Difficulty: EASY
Tags: Implementation

Starter code:

Solutions:
(m, n) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
for i in a:
	if n % i == 0:
		b = i
print(n // b)


(n, k) = [int(i) for i in input().split()]
ans = 10000
for v in [int(i) for i in input().split()]:
	if k % v == 0:
		ans = min(ans, k // v)
print(ans)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
print(min((k // i for i in a if k % i == 0)))


(n, k) = (int(t) for t in input().split())
ans = 10000
c = map(int, input().split())
for ai in c:
	if k % ai == 0 and k / ai < ans:
		ans = k / ai
print('%d' % ans)


(n, k) = (int(x) for x in input().split())
buckets = list(map(int, input().split()))
max = 0
for bucket in buckets:
	if k % bucket == 0 and max < bucket:
		max = bucket
print(int(k / max))


(m, n) = map(int, input().split())
a = list(map(int, input().split()))
m += 222
for e in a:
	if n % e == 0:
		m = min(m, n // e)
print(m)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
m = 0
for x in a:
	if k % x == 0 and x > m:
		m = x
print(k // m)


(n, k) = map(int, input().split())
w = list(map(int, input().split()))
w = [i for i in w if k % i == 0]
print(k // max(w))


(n, k) = map(int, input().split())
L = input().split()
m = 101
for a in L:
	a = int(a)
	if k % a == 0:
		r = k // a
		if r < m:
			m = r
print(m)


(n, k) = map(int, input().split(' '))
h = 1
l = input()
l = l.split()
for i in range(n):
	a = int(l[i])
	if k % a == 0:
		if h < a:
			h = a
print(int(k / h))


ch = input('')
l = ch.split()
y = int(l[-1])
while 1:
	ch2 = input('')
	l2 = ch2.split()
	if len(l2) == int(l[0]):
		break
c = 100
for i in range(0, int(l[0])):
	x = int(l2[i])
	if y % x == 0:
		m = y / x
		if m < c:
			c = m
print(round(c))


a = [int(i) for i in input().split()]
b = sorted([int(i) for i in input().split()])
for i in range(a[0]):
	if a[1] % b[-1] == 0:
		print(a[1] // b[-1])
		break
	else:
		b = b[:-1]


(bucket_count, seg_len) = [int(x) for x in input().split()]
bucket_size = [int(x) for x in input().split()]
mins = int(10000000000.0)
for i in bucket_size:
	if seg_len % i == 0:
		mins = min(mins, seg_len // i)
print(mins)


s = input().split()
n = int(s[0])
k = int(s[1])
m = k
s1 = input().split()
for i in range(n):
	if k % int(s1[i]) == 0:
		if k // int(s1[i]) < m:
			m = k // int(s1[i])
print(m)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mn = 1001
for i in range(n):
	if k % a[i] == 0:
		mn = min(mn, k / a[i])
print(int(mn))


firstline = input().strip().split(' ')
n = int(firstline[0])
k = int(firstline[1])
bucketspeeds = input().strip().split(' ')
largestbucketspeed = 0
for i in range(n):
	if int(bucketspeeds[i]) > largestbucketspeed:
		if k % int(bucketspeeds[i]) == 0:
			largestbucketspeed = int(bucketspeeds[i])
print(int(k / largestbucketspeed))


(n, k) = map(int, input().split())
lst = [int(x) for x in input().split()]
a = 1
for i in range(n):
	if k % lst[i] == 0 and k // lst[i] < k // a:
		a = lst[i]
print(k // a)


s1 = input()
s2 = input()
s1 = s1.split()
s2 = s2.split()
n = int(s1[0])
k = int(s1[1])
a = []
for i in s2:
	a.append(int(i))
a.sort()
t = n - 1
while t >= 0:
	if k % a[t] == 0:
		print(int(k / a[t]))
		break
	else:
		t -= 1


def isfet(i, k):
	return k % i == 0
t = []
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(len(a)):
	if isfet(a[i], k):
		t.append(a[i])
z = max(t)
print(k // z)


(n, k) = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
b = []
for i in a:
	if k % i == 0:
		b.append(k // i)
print(min(b))


(a, b) = map(int, input().split())
s = list(map(int, input().split()))
d = []
for i in s:
	if b % i == 0:
		d.append(i)
print(b // max(d))


s = input().split()
(n, k) = (int(s[0]), int(s[1]))
s = input().split()
min_h = 101
for i in range(n):
	val = int(s[i])
	if k % val == 0 and k // val < min_h:
		min_h = k // val
print(min_h)


(n, k) = list(map(int, input().strip().split()))
a = list(map(int, input().strip().split()))
answer = float('inf')
for i in a:
	if k % i == 0:
		answer = min(answer, k // i)
print(answer)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
v = 0
for i in range(n):
	if k % a[i] == 0:
		if a[i] > v:
			v = a[i]
res = int(k / v)
print(res)


(n, k) = map(int, input().split())
ans = 100000000000
for i in input().split():
	x = int(i)
	if k % x == 0:
		if int(k / x) < ans:
			ans = int(k / x)
print(ans)


f = lambda : map(int, input().split())
(n, k) = f()
ll = max((a for a in f() if not k % a))
print(k // ll)


(n, k) = map(int, input().split())
ans = 1
a = list(map(int, input().split()))
for v in a:
	if k % v == 0:
		ans = max(ans, v)
print(k // ans)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
res = k
for i in a:
	if k % i == 0 and k // i < res:
		res = k // i
print(res)


(n, k) = map(int, input().split(' '))
i = map(int, input().split(' '))
max = 0
for j in i:
	if k % j == 0 and j > max:
		max = j
print(k // max)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a = sorted(a, reverse=True, key=int)
for i in a:
	if k % i == 0:
		print(k // i)
		break


(n, k) = map(int, input().split(' '))
lengths = map(int, input().split(' '))
min_hours = k
for l in lengths:
	if k % l == 0:
		hours = int(k / l)
		if hours < min_hours:
			min_hours = hours
print(min_hours)


def sol():
	(n, k) = map(int, input().split())
	A = [int(i) for i in input().split()]
	p = 0
	for i in range(1, k + 1):
		if k % i == 0 and i in A:
			p = i
	print(k // p)
sol()


(n, k) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
print(min([k // a for a in arr if k % a == 0]))


(n, k) = list(map(int, input().split()))
a = [int(i) for i in input().split()]
minim = 10 ** 18
for i in a:
	if k % i == 0:
		minim = min(minim, k // i)
print(minim)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a = list(filter(lambda x: k % x == 0, a))
print(k // max(a))


(n, k) = list(map(int, input().split()))
t = list(map(int, input().split()))
t.sort(reverse=True)
for i in t:
	if k % i == 0:
		print(k // i)
		exit(0)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
l2 = []
for x in l:
	if k % x == 0:
		l2.append(x)
print(k // max(l2))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
minHours = 999999
for x in a:
	if k // x * x == k:
		minHours = min(minHours, k // x)
print(minHours)


len_garden = int(input().split()[1])
buckets = [int(a) for a in input().split()]
buckets = sorted(buckets, reverse=True)
for i in buckets:
	if len_garden % i == 0:
		print(int(len_garden / i))
		break


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a = filter(lambda x: k % x[1] == 0 and k >= x[1], enumerate(a))
print(int(k / max(a, key=lambda x: x[1])[1]))


(n, k) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
ret = 1000000
for x in arr:
	if k % x == 0 and k // x < ret:
		ret = k // x
print(ret)


(a, b) = map(int, input().split())
c = list(map(int, input().split()))
c.sort()
c.reverse()
for i in c:
	if b % i == 0:
		print(b // i)
		break


(x, y) = input().split()
x = int(x)
y = int(y)
n = list(map(int, input().split()))
n.sort(reverse=True)
for i in n:
	if y % i == 0:
		print(int(y / i))
		break


(n, k) = map(int, input().split())
bucket = list(map(int, input().split()))
bucket.sort(reverse=True)
ans = 0
for i in bucket:
	if k % i == 0:
		ans = k // i
		print(ans)
		break


s = list(map(int, input().split()))
list_of_lengths = list(map(int, input().split()))
a = []
for j in list_of_lengths:
	if s[1] % j == 0:
		a.append(int(s[1] // j))
print(min(a))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
m = k
for i in range(len(a)):
	if k % a[i] == 0 and k // a[i] <= m:
		m = k // a[i]
print(m)


(n, k) = list(map(int, input().split()))
r = 10 ** 9
for l in list(map(int, input().split())):
	if k % l == 0:
		r = min(r, k // l)
print(r)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
arr2 = list()
for v in arr:
	if k % v == 0:
		arr2 += [v]
print(k // max(arr2))


(n, m) = map(int, input().split())
l = sorted(list(map(int, input().split())), reverse=True)
for i in l:
	if m % i == 0:
		print(m // i)
		break


a = [int(q) for q in input().strip().split()]
b = [int(q) for q in input().strip().split()]
min = 200
for k in range(a[0]):
	if a[1] % b[k] == 0:
		if a[1] / b[k] < min:
			min = a[1] / b[k]
print(int(min))


a = list(map(int, input().split()))
b = list(map(int, input().split()))
s = []
temp = 0
for i in range(a[0]):
	if a[1] % b[i] == 0:
		s.append(int(a[1] // b[i]))
print(min(s))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(key=lambda x: -x)
for i in range(n):
	if k % a[i] == 0:
		print(k // a[i])
		break


ans1 = input()
(n, k) = list(map(int, ans1.split()))
ans2 = input()
buckets = list(map(int, ans2.split()))
bestHours = 0
for a in buckets:
	if (k / a < bestHours or bestHours == 0) and k % a == 0:
		bestHours = k // a
print(bestHours)


(n, k) = map(int, input().split())
a = sorted(list(map(int, input().split())))[::-1]
for i in a:
	if k % i == 0:
		print(k // i)
		break


(n, k) = map(int, input().split())
mas = list(map(int, input().split()))
mas.sort()
mas.reverse()
for i in range(n):
	if k % mas[i] == 0:
		print(k // mas[i])
		break


nk = input()
bucketString = input()
nklist = nk.split(' ')
n = int(nklist[0])
k = int(nklist[1])
buckets = bucketString.split(' ')
divisiveis = []
for i in buckets:
	if k % int(i) == 0:
		divisiveis.append(int(i))
maiorDiv = max(divisiveis)
resposta = k // maiorDiv
print(resposta)


import math

def func(num_buckets, length, buckets):
	lista = []
	for i in range(num_buckets):
		if length % buckets[i] == 0:
			lista.append(buckets[i])
	return int(length / max(lista))
(num_buckets, length) = list(map(int, input().split()))
buckets = list(map(int, input().split()))
hours = func(num_buckets, length, buckets)
print(hours)


(n, k) = map(int, input().split())
l = [*map(int, input().split())]
l.sort()
for i in range(n - 1, -1, -1):
	if k % l[i] == 0:
		print(k // l[i])
		break


(n, k) = map(int, input().split())
row = list(map(int, input().split()))
b = max((x for x in row if k % x == 0))
print(k // b)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
a = 0
for i in range(n):
	if k % l[i] == 0 and l[i] > a:
		a = l[i]
print(k // a)


(N, K) = map(int, input().split())
src = list(map(int, input().split()))
for a in reversed(sorted(src)):
	if a > K:
		continue
	if K % a == 0:
		print(K // a)
		exit()


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
m = k
for i in l:
	if k % i == 0 and k // i < m:
		m = k // i
print(m)


(n, k) = map(int, input().split())
buckets = list(map(int, input().split()))
buckets.sort()
for i in range(len(buckets) - 1, -1, -1):
	if k % buckets[i] == 0:
		print(int(k / buckets[i]))
		break


(_, k) = map(int, input().split())
for a in sorted(map(int, input().split()), reverse=True):
	if k % a == 0:
		print(k // a)
		break


(n, k) = map(int, input().split())
maxi = 0
a = list(map(int, input().split()))
for i in a:
	if k % i == 0:
		maxi = max(maxi, i)
print(k // maxi)


inp = lambda : map(int, input().split())
(n, k) = inp()
a = list(inp())
m = -1
for i in range(n):
	if k % a[i] == 0:
		m = max(m, a[i])
print(int(k / m))


(n, k) = map(int, input().split())
ar = [int(p) for p in input().split()]
ar.sort()
for i in range(n - 1, -1, -1):
	if not k % ar[i]:
		print(k // ar[i])
		break


import math
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mn = 1000
for i in range(n):
	if k % a[i] == 0 and k / a[i] < mn:
		mn = k / a[i]
print(math.trunc(mn))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
(N, K) = map(int, input().split())
A = [int(x) for x in input().split()]
ans = float('inf')
for x in A:
	if K % x == 0:
		ans = min(ans, K // x)
print(ans)


(n, k) = [int(x) for x in input().split(' ')]
a = [int(x) for x in input().split(' ')]
for i in range(1, k + 1):
	if k % i == 0 and k // i in a:
		ans = i
		break
print(ans)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mb = []
for i in range(n):
	if k % a[i] == 0:
		mb.append(k // a[i])
print(min(mb))


(n, m) = input().split()
n = int(n)
m = int(m)
a = list(map(int, input().split()))
ans = 1000
for c in a:
	if m % c == 0:
		g = m // c
		if g < ans:
			ans = g
print(ans)


(n, k) = map(lambda x: int(x), input().split(' '))
buckets = list(map(lambda x: int(x), input().split(' ')))
buckets = sorted(buckets, reverse=True)
for b in buckets:
	if k % b == 0:
		print(int(k / b))
		break


r = lambda : map(int, input().split())
(b, g) = r()
buck = sorted(list(r()), reverse=True)
for x in buck:
	if not g % x:
		print(g // x)
		break


(n, k) = map(int, input().split())
b = map(int, input().split())
c = list(map(lambda a: k / a, b))
min = 101
for v in c:
	if v.is_integer() and v < min:
		min = v
print(int(min))


(n, k) = map(int, input().split())
(vs, m) = (list(map(int, input().split())), k)
for i in vs:
	if k // i == k / i and k // i < m:
		m = k // i
print(m)


y = list(map(int, input().split()))
z = list(map(int, input().split()))
p = []
for i in z:
	if y[1] % i == 0:
		p.append(y[1] // i)
print(min(p))


(size, leng) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
for i in reversed(arr):
	if leng % i == 0:
		print(leng // i)
		exit(0)


from sys import stdin
from io import StringIO
(n, k) = map(int, stdin.readline().strip().split())
a = list(map(int, stdin.readline().strip().split()))
ans = None
for i in a:
	if k % i == 0:
		if not ans or ans > k // i:
			ans = k // i
print(ans)


(n, k) = list(map(lambda k: int(k), input().split()))
a = list(map(lambda k: int(k), input().split()))
min_hour = k
for ai in a:
	if k % ai == 0:
		min_hour = min(min_hour, k // ai)
print(min_hour)


entry = input().split()
objectiveArea = int(entry[1])
bucketCapacity = input().split()
for current in range(len(bucketCapacity)):
	bucketCapacity[current] = int(bucketCapacity[current])
bestBucket = 0
for current in bucketCapacity:
	if objectiveArea / current == objectiveArea // current:
		if current > bestBucket:
			bestBucket = current
print(objectiveArea // bestBucket)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
ans = 100000
for t in a:
	if k % t == 0 and k // t < ans:
		ans = k // t
print(ans)


a = lambda : map(int, input().split())
(b, c) = a()
print(min((c // i for i in sorted(list(a()), reverse=True) if c % i == 0)))


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
bucket = -1
for i in range(n):
	if not k % a[i]:
		bucket = max(bucket, a[i])
print(k // bucket)


(n, l) = map(int, input().split())
a = list(map(int, input().split()))
mini = l + 1
for i in range(n):
	if a[i] > l:
		continue
	k = l // a[i]
	if l % a[i] == 0 and k < mini and (k != 0):
		mini = k
		ans = a[i]
print(mini)


(n, k) = map(int, input().split())
A = [*map(int, input().split())]
ans = 0
for a in sorted(A, reverse=True):
	if k % a == 0:
		ans = a
		break
print(k // ans)


(n, k) = map(int, input().split())
ai = list(map(int, input().split()))
b = 0
for x in ai:
	if k % x == 0 and x > b:
		b = x
		res = k // x
print(res)


(totalBaldes, tamJardim) = [int(i) for i in input().split()]
baldes = [int(i) for i in input().split()]
baldeEscolhido = 0
for i in baldes:
	if tamJardim % i == 0 and i > baldeEscolhido:
		baldeEscolhido = i
print(tamJardim // baldeEscolhido)


b = list(map(int, input().split()))
n = b[0]
k = b[1]
a = list(map(int, input().split()))
a.sort(reverse=True)
for i in range(0, n):
	if k % a[i] == 0:
		print(int(k / a[i]))
		break
	else:
		continue


(a, b) = list(map(int, input().split()))
l = list(map(int, input().split()))
l.sort()
for i in range(len(l) - 1, -1, -1):
	if b % l[i] == 0:
		print(b // l[i])
		break


(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = list(reversed(sorted(a)))
for i in range(n):
	if k % a[i] == 0:
		print(k // a[i])
		break


(n, k) = map(int, input().split())
ai = list(map(int, input().split()))
b = 0
for i in range(0, n):
	if k % ai[i] == 0 and ai[i] > b:
		b = ai[i]
print(k // b)


(n, k) = [int(i) for i in input().split()]
S = [int(i) for i in input().split()]
for i in sorted(S, reverse=1):
	if k % i == 0:
		print(k // i)
		break


n_k = input().split(' ')
n = int(n_k[0])
k = int(n_k[1])
buckets = input().split(' ')
buckets = [int(x) for x in buckets]
buckets.sort(reverse=True)
for bucket in buckets:
	if k % bucket == 0:
		print(k // bucket)
		break


(n, k) = tuple(map(int, input().split()))
a = [int(x) for x in input().split()]
a1 = []
for b in a:
	if k % b == 0:
		a1.append(b)
print(k // max(a1))


(n, k) = map(int, input().split())
li = list(map(int, input().split()))
s = 0
for i in li[:n]:
	if k % i == 0 and i > s:
		s = i
print(k // s)


Read = lambda : list(map(int, input().split()))
(n, k) = Read()
print(k // max((x for x in Read() if k % x == 0)))


L = int(input().split()[1])
print(L // max((d for d in map(int, input().split()) if L % d == 0)))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 0
for item in a:
	if k % item == 0:
		ans = max(ans, item)
print(k // ans)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
Ans = 100
for i in range(n):
	if k % a[i] == 0:
		Ans = min(Ans, k // a[i])
print(Ans)


(n, k) = map(int, input().split())
a = list(input().split())
output = 0
for i in range(len(a)):
	if k % int(a[i]) == 0:
		if output == 0:
			output = k // int(a[i])
		else:
			output = min(output, k // int(a[i]))
print(output)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
k_a = []
for i in range(n):
	if k % a[i] == 0:
		k_a.append(k / a[i])
print(int(min(k_a)))


(n, k) = (0, list(map(int, input().split()))[1])
a = list(map(int, input().split()))
a.sort(reverse=True)
for i in a:
	if k % i == 0:
		print(k // i)
		break


from sys import stdin, stdout
Input = []
Input = [stdin.readlines()]
Input = Input[0]
Input = [x.split(' ') for x in Input]
n = int(Input[0][0])
k = int(Input[0][1])
a = [int(x) for x in Input[1]]
moda = [k % x for x in a]
good = []
for i in range(n):
	if moda[i] == 0:
		good.append(a[i])
stdout.write(str(int(k / max(good))))


(n, k) = map(int, input().split())
a = map(int, input().split())
result = k
for x in a:
	if k % x == 0:
		result = min(result, k // x)
print(result)


R = lambda : map(int, input().split())
(n, k) = R()
a = list(R())
ans = 0
for i in range(n):
	if k % a[i] == 0 and a[i] > ans:
		ans = a[i]
print(int(k / ans))


p = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort(reverse=True)
i = 0
while i < p[0]:
	if p[1] % a[i] == 0:
		break
	i += 1
print(p[1] // a[i])


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
mini = 10000
for i in arr:
	if k % i == 0:
		if k // i < mini:
			mini = k // i
print(mini)


(nk, Segments) = (list(map(int, input().split())), sorted(list(map(int, input().split()))))
(n, k) = (nk[0], nk[1])
for i in range(n - 1, -1, -1):
	if k % Segments[i] == 0:
		print(k // Segments[i])
		exit()


def main():
	(n, k) = map(int, input().split())
	a = map(int, input().split())
	r = max((i for i in a if k % i == 0))
	print(k // r)
main()


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
min1 = float('inf')
for i in range(n):
	if k % a[i] == 0:
		if k // a[i] < min1:
			min1 = k // a[i]
print(min1)


input1 = input().split()
n = int(input1[0])
k = int(input1[1])
vetor = sorted([int(c) for c in input().split()])
i = n - 1
while i >= 0:
	seg = vetor[i]
	if k % seg == 0:
		print(k // seg)
		break
	i -= 1


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
print(min(map(lambda ai: k // ai, filter(lambda ai: k % ai == 0, a))))


(n, k) = map(int, input().split())
l = input().split()
ans = 10000000000
for item in l:
	t = int(item)
	if k % t == 0:
		ans = min(ans, int(k / t))
print(ans)


k = int(input().split()[1])
for a in sorted(map(int, input().split()), reverse=True):
	if not k % a:
		break
print(k // a)


(buckets, lenOfGarden) = [*map(int, input().split())]
buck = [*map(int, input().split())]
buck.sort()
maxi = 0
for i in range(buckets):
	if lenOfGarden % buck[i] == 0:
		maxi = lenOfGarden // buck[i]
print(maxi)


(n, k) = map(int, input().split())
buc = list(map(int, input().split()))
l = []
for i in range(n):
	if k % buc[i] == 0:
		l.append(buc[i])
l.sort()
print(int(k / l[-1]))


import itertools as it, math, functools as ft
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
res = 100000
for i in a:
	if k % i == 0:
		res = min(res, k // i)
print(res)


(vedra, dlina) = map(int, input().split())
dlinaOtrezkov = list(map(int, input().split()))
dlinaOtrezkov.sort()
dlinaOtrezkov.reverse()
counter = -5
for i in range(0, vedra):
	if dlinaOtrezkov[i] <= dlina and dlina % dlinaOtrezkov[i] == 0:
		counter = dlinaOtrezkov[i]
		break
	else:
		i = i
print(dlina // counter)


input_ = list(input().split(' '))
number_buckets = int(input_[0])
garden_length = int(input_[-1])
buckets = [int(bucket) for bucket in input().split(' ')]
buckets = sorted(buckets)
possible_bucket = 0
for bucket in buckets:
	if bucket > garden_length:
		break
	if garden_length % bucket == 0:
		possible_bucket = bucket
num_hours = garden_length // possible_bucket
print(num_hours)


import math
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mx = 100000000000
for i in a:
	if k % i == 0:
		mx = min(mx, k // i)
print(mx)


S = input()
I = input()
S = S.split(' ')
I = I.split(' ')
Tama = int(S[0])
TamaG = int(S[1])
L = []
for i in range(0, Tama):
	L.append(int(I[i]))
L1 = []
for i in L:
	if TamaG % i == 0:
		L1.append(TamaG / i)
L1.sort()
print(int(L1[0]))


(n, k) = map(int, input().split())
num = [int(x) for x in input().split()]
res = []
for i in num:
	if k % i == 0:
		res.append(k // i)
print(min(res))


x = list(map(int, input().split()))
y = list(map(int, input().split()))
A = []
for i in range(x[0]):
	if x[1] % y[i] == 0:
		A.append(x[1] // y[i])
print(min(A))


import sys
import math
input = sys.stdin.readline
for _ in range(1):
	(n, k) = map(int, input().split())
	l = list(map(int, input().split()))
	ans = 10 ** 18
	for i in l:
		if k % i == 0:
			ans = min(ans, k // i)
	print(ans)


(buckets, gard_length) = list(map(int, input().split()))
len_per_hour = list(map(int, input().split()))
maximum = 0
for i in range(len(len_per_hour)):
	if len_per_hour[i] > maximum and gard_length % len_per_hour[i] == 0:
		maximum = len_per_hour[i]
print(gard_length // maximum)


(n, k) = map(int, input().split())
ai = list(map(int, input().split()))
bi = []
for i in ai:
	if k % i == 0:
		bi.append(i)
print(int(k / max(bi)))


(n, k) = list(map(int, input().split()))
tab = [int(x) for x in input().split()]
best = 1
for i in tab:
	if k % i == 0:
		best = max([i, best])
print(k // best)


from bisect import bisect_right as br
import sys
from collections import *
from math import *
import re

def sieve(n):
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p * p, n + 1, p):
				prime[i] = False
		p += 1
	c = 0
	for i in range(2, n):
		if prime[i]:
			c += 1
	return c

def totient(n):
	(res, p) = (n, 2)
	while p * p <= n:
		if n % p == 0:
			while n % p == 0:
				n = n // p
			res -= int(res / p)
		p += 1
	if n > 1:
		res -= int(res / n)
	return res

def iseven(n):
	return [False, True][0 if n % 2 else 1]

def inp_matrix(n):
	return list(([input().split()] for i in range(n)))

def inp_arr():
	return list(map(int, input().split()))

def inp_integers():
	return map(int, input().split())

def inp_strings():
	return input().split()

def lcm(a, b):
	return a * b / gcd(a, b)
max_int = sys.maxsize
mod = 10 ** 9 + 7
flag1 = False
flag2 = False
(n, k) = inp_integers()
arr = inp_arr()
ans = 0
print(k // max([i for i in arr if k % i == 0]))


(n, k) = list(map(int, input().strip().split()))
a = list(map(int, input().strip().split()))
maks = 0
for e in a:
	if k % e == 0:
		maks = max(maks, e)
print(k // maks)


import sys
import math
get_string = lambda : sys.stdin.readline().strip()
get_int_list = lambda : list(map(int, sys.stdin.readline().strip().split()))
get_intList_from_str = lambda : list(map(int, list(sys.stdin.readline().strip())))
get_charList_from_str = lambda : list(sys.stdin.readline().strip())
get_char_list = lambda : sys.stdin.readline().strip().split()
get_int = lambda : int(sys.stdin.readline())
pt = lambda x: sys.stdout.write(str(x))
(n, k) = get_int_list()
lst = get_int_list()
m = -10000
for i in range(n):
	if k % lst[i] == 0:
		m = max(m, lst[i])
print(k // m)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 1000000000.0 + 7
for i in a:
	if k % i == 0:
		ans = min(ans, k // i)
print(ans)


import math
(n, k) = map(int, input().split())
segment = [int(s) for s in input().split()]
segment.sort(reverse=True)
for s in segment:
	if k % s == 0:
		print(math.floor(k / s))
		break


(n, k) = [int(i) for i in input().split()]
x = [int(i) for i in input().split()]
ans = []
for i in range(0, len(x)):
	if k % x[i] == 0:
		s = k // x[i]
		ans.append(s)
print(min(ans))


(noOfbuckets, garden) = map(int, input().split(' '))
buckets_length = list(map(int, input().split(' ')))
can_choose = [i for i in buckets_length if garden % i == 0]
choosed_bucket = max(can_choose)
print(garden // choosed_bucket)


(n, k) = map(int, input().split())
kl = list(map(int, input().split()))
kl.sort()
for x in kl:
	if k % x == 0:
		temp = x
print(int(k / temp))


mas1 = input().split(' ')
mas2 = input().split(' ')
n = int(mas1[0])
k = int(mas1[1])
max_vedro = 0
for i in mas2:
	swap_vedro = int(i)
	if k % swap_vedro == 0 and swap_vedro > max_vedro:
		max_vedro = swap_vedro
print(k // max_vedro)


import math, string, itertools, fractions, heapq, collections, re, array, bisect, sys, random, time, copy, functools
sys.setrecursionlimit(10 ** 7)
inf = 10 ** 20
eps = 1.0 / 10 ** 15
mod = 10 ** 9 + 7

def LI():
	return [int(x) for x in sys.stdin.readline().split()]

def LI_():
	return [int(x) - 1 for x in sys.stdin.readline().split()]

def LF():
	return [float(x) for x in sys.stdin.readline().split()]

def LS():
	return sys.stdin.readline().split()

def I():
	return int(sys.stdin.readline())

def F():
	return float(sys.stdin.readline())

def S():
	return input()

def pf(s):
	return print(s, flush=True)

def main():
	(n, k) = LI()
	r = inf
	a = LI()
	for c in a:
		if k % c != 0:
			continue
		t = k // c
		if r > t:
			r = t
	return r
print(main())


def solve(n, k, A):
	for a in reversed(sorted(A)):
		if k % a == 0:
			return int(k / a)
	return -1
n = [int(i) for i in input().split()]
k = n[1]
n = n[0]
A = [int(i) for i in input().split()]
print(solve(n, k, A))


import sys
options = []
[n, k] = list(map(int, sys.stdin.readline().strip().split(' ')))
buckets = list(map(int, sys.stdin.readline().strip().split(' ')))
for i in range(len(buckets)):
	if k % buckets[i] == 0:
		options.append(buckets[i])
print(k // max(options))


ch = input('')
(n, k) = (int(ch.split(' ')[0]), int(ch.split(' ')[1]))
ch = input('')
l = []
for i in range(n):
	l.append(int(ch.split(' ')[i]))
lv = []
for i in l:
	if k % i == 0:
		lv.append(i)
lv.sort()
h = k // lv[-1]
print(h)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = k
for i in range(n):
	kai = k // a[i]
	if kai == k / a[i]:
		if ans > kai:
			ans = kai
print(ans)


(n, k) = input().split(' ')
buckets = [int(a) for a in input().split(' ')]
k = int(k)
buckets = reversed(sorted(buckets))
for bucket in buckets:
	if k % bucket == 0:
		print(k // bucket)
		break


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
q = []
for i in l:
	if k % i == 0:
		q.append(i)
print(k // max(q))


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort()
for i in range(n - 1, -1, -1):
	if k % a[i] == 0:
		print(k // a[i])
		break


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
b = []
for i in range(n):
	if k % a[i] == 0:
		b.append(a[i])
print(k // max(b))


nk = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
for i in range(nk[0] - 1, -1, -1):
	if nk[1] % a[i] == 0:
		print(nk[1] // a[i])
		break


import sys
input = sys.stdin.readline

def I():
	return input().strip()

def II():
	return int(input().strip())

def LI():
	return [*map(int, input().strip().split())]
import math
(n, k) = map(int, input().split())
lst = LI()
lst.sort(reverse=True)
for i in range(n):
	if k % lst[i] == 0:
		print(k // lst[i])
		break


(_, m) = map(int, input().split())
a = max([int(i) for i in input().split() if m % int(i) == 0])
print(m // a)


(n, k) = [int(i) for i in input().split(' ')]
array = [int(i) for i in input().split()]
array.sort()
res = 0
for i in array:
	if k % i == 0:
		res = k / i
print(int(res))


(a, b) = [int(i) for i in input().split()]
dig = [int(i) for i in input().split()]
res = b + 1
for i in range(len(dig)):
	if b % dig[i] == 0 and b // dig[i] < res:
		res = b // dig[i]
print(res)


(_, g) = [int(x) for x in input().split()]
buckets = sorted([int(x) for x in input().split()])
for b in buckets[-1::-1]:
	if g % b == 0:
		print(int(g / b))
		exit()


(n, length) = map(int, input().split())
buckets = list(map(int, input().split()))
hours = float('inf')
for b in buckets:
	if length % b == 0:
		hours = min(hours, length // b)
print(hours)


num_tam = input()
baldes = input()
lista_num_tam = num_tam.split(' ')
tam = int(lista_num_tam[1])
lista_baldes = baldes.split(' ')
tam_baldes = [tam / int(i) for i in lista_baldes if tam % int(i) == 0]
print(int(min(tam_baldes)))


(n, k) = map(int, input().split(' '))
buckets = list(map(int, input().split(' ')))
best_bucket = -1
for bucket in buckets:
	if k % bucket == 0 and bucket > best_bucket:
		best_bucket = bucket
print(int(k / best_bucket))


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
arr.sort()
for item in arr:
	if k / item == k // item:
		mn = k // item
print(mn)


i = list(map(int, input().split()))
buckets = list(map(int, input().split()))
n = i[0]
k = i[1]
min = 99999999999999999999999999999
for bucket in buckets:
	if k / bucket < min:
		if k % bucket == 0:
			min = k / bucket
	else:
		pass
print(int(min))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 100000
for N in a:
	if k % N == 0:
		ans = min(ans, k // N)
print(ans)


(n, k) = map(int, input().split())
b = map(int, input().split())
print(min((k // x for x in b if k % x == 0)))


import sys

def rs():
	return sys.stdin.readline().rstrip()

def ri():
	return int(sys.stdin.readline())

def ria():
	return list(map(int, sys.stdin.readline().split()))

def ws(s):
	sys.stdout.write(s)
	sys.stdout.write('\n')

def wi(n):
	sys.stdout.write(str(n))
	sys.stdout.write('\n')

def wia(a, sep=' '):
	sys.stdout.write(sep.join([str(x) for x in a]))
	sys.stdout.write('\n')

def main():
	(n, k) = ria()
	a = ria()
	a = sorted(a, reverse=True)
	for i in range(n):
		if k % a[i] == 0:
			wi(k // a[i])
			return
main()


(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
d = []
for x in range(len(a)):
	if k % a[x] == 0:
		d.append(a[x])
print(k // max(d))


x = list(map(int, input().split()))
n = list(map(int, input().split()))
max = 1
for i in range(x[0]):
	if x[1] % n[i] == 0:
		if n[i] > max:
			max = n[i]
print(str(int(x[1] / max)))


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
mini = 1000
for i in range(n):
	q = k / a[i]
	if int(q) == q:
		if q < mini:
			mini = q
print(int(mini))


(n, m) = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
l.sort()
l.reverse()
for k in l:
	if m % k == 0:
		print(int(m / k))
		break


(n, k) = list(map(int, input().split()))
arr = list(map(int, input().split()))
m = 0
for el in arr:
	if k % el == 0 and el > m:
		m = el
print(k // m)


(n, k) = map(int, input().strip().split())
c = [int(i) for i in input().split(' ')]
min_n = 1000
for i in c:
	if k % i == 0:
		min_n = min(k / i, min_n)
print(int(min_n))


(n, k) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
print(int(min([k / x for x in list(filter(lambda x: k % x == 0, a))])))


def is_prime(a):
	return all((a % i for i in range(2, a)))
(n, k) = map(int, input().split())
l = [int(x) for x in input().split()]
if is_prime(k):
	if k in l:
		print(1)
	else:
		print(k)
else:
	ll = []
	for i in range(len(l)):
		if k % l[i] == 0:
			ll.append(l[i])
	print(k // max(ll))


(_, garden_length) = map(int, input().split())
buckets = map(int, input().split())
min_hours = int(min([garden_length / bucket for bucket in buckets if garden_length % bucket == 0]))
print(min_hours)


from operator import itemgetter
(n, k) = map(int, input().split())
ai = list(map(int, input().split()))
ans = 0
ai.sort()
for i in range(n - 1, -1, -1):
	if k % ai[i] == 0:
		ans = k // ai[i]
		break
print(ans)


import sys
(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
res = 10000000
for i in range(n):
	if k % arr[i] == 0:
		res = min(res, k // arr[i])
print(res)


(n, k) = map(int, input().split())
l = [int(x) for x in input().split()]
mx = 0
for i in range(n):
	if k % l[i] != 0:
		l[i] = 0
print(k // max(l))


(n, k) = [int(f) for f in input().split(' ') if f]
d = [int(f) for f in input().split(' ') if f]
result = k + 1
for i in range(len(d)):
	if k % d[i] == 0:
		result = min(result, k // d[i])
print(result)


s = input()
[n, k] = list(map(int, s.split()))
max_n = -1
t = input()
for _ in range(n):
	numbers = map(int, t.split())
	for a in numbers:
		if k % a == 0 and a > max_n:
			max_n = a
print(k // max_n)


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
x = 101
for i in range(n):
	if m % l[i] == 0:
		a = min(m // l[i], x)
		x = a
print(a)


(n, k) = (int(x) for x in input().strip().split())
mn = 10000
for x in input().strip().split():
	a = int(x)
	if k % a == 0:
		mn = min(k / a, mn)
print(int(mn))


(n, k) = map(int, input().split())
for i in sorted(map(int, input().split()), reverse=True):
	if k % i == 0:
		print(k // i)
		break


(n, k) = map(int, input().split())
ans = 10 ** 18
for a in map(int, input().split()):
	if k % a == 0:
		ans = min(ans, k // a)
print(ans)


string = input().split(' ')
n = int(string[0])
k = int(string[1])
buckets = input().split(' ')
time = float('inf')
for num in buckets:
	if k % int(num) == 0:
		timeTaken = k // int(num)
		if timeTaken < time:
			time = timeTaken
print(time)


(n, k) = input().split()
a = [int(x) for x in input().split()][:int(n)]
k = int(k)
maxi = 0
for x in a:
	if k % x == 0:
		if x > maxi:
			maxi = x
print(k // maxi)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
x = 0
z = 0
for i in l:
	if k % i == 0:
		if z < i:
			z = i
x = k // z
print(x)


(n, k) = map(int, input().split())
ans = 1000000000000
for x in input().split():
	ans = min(k / int(x) if k % int(x) == 0 and k >= int(x) else 1000000000000, ans)
print(int(ans))


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
while True:
	index = None
	var = -1
	for i in range(n):
		if arr[i] > var:
			index = i
			var = arr[i]
	if k % var == 0:
		print(int(k / var))
		break
	arr[index] = -1


(n, k) = list(map(int, input().split()))
possible = []
for x in map(int, input().split()):
	if k % x == 0:
		possible.append(x)
print(min([k // x for x in possible]))


c = input()
(n, k) = [int(x) for x in c.strip().split(' ')]
a = [int(i) for i in input().strip().split(' ')]
a.sort(reverse=True)
for i in a:
	if k % i == 0:
		print(int(k / i))
		break


(n, k) = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
h = 100000000000
for a in A:
	if k % a == 0:
		h = min(h, k // a)
print(h)


str1 = input().split(' ')
str2 = input().split(' ')
temp = 0
for i in range(0, len(str2)):
	if int(str2[i]) > temp and int(str1[1]) % int(str2[i]) == 0:
		temp = int(str2[i])
print(int(int(str1[1]) / int(temp)))


(n, k) = map(int, input().split())
l = [int(x) for x in input().split()]
ans = 10 ** 20
for i in range(n):
	if k % l[i] == 0:
		ans = min(ans, k // l[i])
print(ans)


(x, y) = [int(i) for i in input().split()]
z = [int(i) for i in input().split()]
z.sort()
for i in z[::-1]:
	if y % i == 0:
		print(y // i)
		break


import sys
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
for x in a:
	if k == k // x * x:
		print(k // x)
		sys.exit(0)


(n, l) = [int(i) for i in input().strip().split()]
arr = [int(i) for i in input().strip().split()]
mi = 10000000000000
for i in arr:
	if l % i == 0:
		mi = min(mi, l // i)
print(mi)


def solve():
	inputs = input().split()
	num_buckets = int(inputs[0])
	garden_len = int(inputs[1])
	buckets = input().split(' ')
	quickest = 1e+40
	for i in range(0, len(buckets)):
		bucket = int(buckets[i])
		if garden_len % bucket == 0:
			if garden_len / bucket < quickest:
				quickest = garden_len / bucket
	print(int(quickest))
solve()


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
l.sort(reverse=True)

def solve():
	for e in l:
		if k % e == 0:
			return k // e
	return -1
print(solve())


(n, c) = input().split()
n = int(n)
c = int(c)
x = [int(x) for x in input().split()]
maximum = 0
for num in x:
	if c % num == 0 and num > maximum:
		maximum = num
print(int(c / maximum))


(c, b) = input().split()
n = int(c)
k = int(b)
b = input().split()
a = []
for x in range(n):
	a.append(int(b[x]))
a.sort()
a.reverse()
for x in range(n):
	if k % a[x] == 0:
		print(k // a[x])
		break


(n, k) = map(int, input().split())
str_input = input()
num = [int(i) for i in str_input.split()]
can_be = []
for m in num:
	if k % m == 0:
		can_be.append(m)
the_result = sorted(can_be)
print(int(k / the_result[-1]))


(n, k) = [int(_) for _ in input().split(' ')]
m = 100
a = [int(__) for __ in input().split(' ')]
for _ in range(n):
	if k % a[_] is 0 and k // a[_] < m:
		m = k // a[_]
print(m)


def is_prime(x):
	for j in range(2, int(x ** 0.5) + 1):
		if x % j == 0:
			return False
	else:
		return True
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mn = []
if is_prime(k):
	exit(print(k if k not in a else 1))
else:
	for i in range(n):
		if k % a[i] == 0:
			mn.append(k // a[i])
print(min(mn))


(n_buckets, garden_length) = map(int, input().strip().split())
segments = sorted(list(map(int, input().strip().split())), reverse=True)
for s in segments:
	if garden_length % s == 0:
		print(garden_length // s)
		break


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
out = None
for ai in a:
	if k % ai == 0:
		if out is None:
			out = k // ai
		else:
			out = min(out, k // ai)
print(out)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
mn = 100000000
for i in l:
	if k % i == 0 and k // i < mn:
		mn = k // i
print(mn)


(n, x) = map(int, input().split())
arr = [int(new) for new in input().split()]
arr.sort(reverse=True)
for i in arr:
	if x % i == 0:
		ans = x // i
		break
print(ans)


(n, k) = [int(x) for x in input().split(' ')]
a = [int(x) for x in input().split(' ')]
for i in sorted(a, reverse=True):
	if k % i == 0:
		print(k // i)
		break


import sys

def sol(n, k, bs):
	bs = sorted(bs)
	for i in range(n - 1, -1, -1):
		if k % bs[i] == 0:
			return k // bs[i]
[n, k] = input().strip().split()
[n, k] = [int(n), int(k)]
bs = [int(x) for x in input().strip().split()]
print(sol(n, k, bs))


(n, k) = list(map(int, input().split()))
t = list(map(int, input().split()))
s = []
for i in range(len(t)):
	if k % t[i] == 0:
		p = k // t[i]
		s.append(p)
print(min(s))


(n, k) = list(map(int, input().split()))
l = list(map(int, input().split()))
m = 1
for i in l:
	if k % i == 0:
		m = max(m, i)
print(k // m)


(n, k) = [int(c) for c in input().split()]
A = [int(c) for c in input().split()]
res = 101
for a in A:
	if k % a == 0 and k // a < res:
		res = k // a
print(res)


import sys
ipt = input().split()
n = int(ipt.pop(0))
k = int(ipt.pop(0))
numbers = [int(i) for i in input().split()]
times = []
for n in numbers:
	if k % n == 0:
		times.append(n)
result = int(k / max(times))
print(result)


k = int(input().split()[1])
a = input().split()
for i in range(len(a)):
	a[i] = int(a[i])
for d in sorted(a, reverse=True):
	if k % d == 0:
		break
print(k // d)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mins = []
for i in a:
	if k % i == 0:
		x = k // i
		mins.append(x)
print(min(mins))


(__, size) = (int(item) for item in input().split())
print(size // max([int(item) for item in input().split() if size % int(item) == 0]))


import sys

def solution(k, buckets):
	buckets.sort(reverse=True)
	for b in buckets:
		if k % b == 0:
			return k // b
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
buckets = list(map(int, input().strip().split(' ')))
print(solution(k, buckets))


def main():
	(n, k) = map(int, input().split())
	arr = list(map(int, input().split()))
	arr = [i for i in arr if k % i == 0]
	print(k // max(arr))
main()


(a, b) = input().split()
mas = input().split()
n = []
for i in mas:
	if int(b) % int(i) == 0:
		n.append(int(int(b) / int(i)))
print(min(n))


(n, k) = list(map(int, input().split(' ')))
buckets = list(map(int, input().split(' ')))
buckets.sort(reverse=True)
for a in buckets:
	if not k % a:
		print(k // a)
		break


(n, k) = map(int, input().split())
min = 101
count = 0
x = 0
b = input().split()
a = list(map(int, b))
for i in range(n):
	while x < k:
		x += a[i]
		count += 1
	if x == k:
		if min > count:
			min = count
		count = 0
		x = 0
	else:
		count = 0
		x = 0
print(min)


from random import randint
(x, y) = map(int, input().split())
arr = sorted(list(map(int, input().split())))
maxi = 1
for i in arr[::-1]:
	if y % i == 0:
		maxi = i
		break
print(y // maxi)


(n, k) = map(int, input().split())
a = sorted(list(map(int, input().split())))
hours = 0
for x in a:
	if x > k:
		break
	elif k % x == 0:
		hours = x
print(k // hours)


l1 = list(map(int, input().split()))
l2 = list(map(int, input().split()))
l2.sort(reverse=True)
for i in l2:
	if l1[1] % i == 0:
		print(l1[1] // i)
		exit()


def solution(k, buckets):
	if k <= 0:
		return 0
	max_bucket = 1
	for bucket in buckets:
		if k % bucket == 0 and bucket > max_bucket:
			max_bucket = bucket
	return k // max_bucket
f = [int(x) for x in input().split()]
(n, k) = (f[0], f[1])
buckets = [int(x) for x in input().split()]
print(solution(k, buckets))


(n, m) = map(int, input().split())
A = list(map(int, input().split()))
A.sort()
ans = None
for i in range(len(A) - 1, -1, -1):
	if m % A[i] == 0:
		ans = m // A[i]
		break
print(ans)


(n, k) = map(int, input().split())
num = list(map(int, input().split()))
ans = 1000000000000000000
for i in range(len(num)):
	if k % num[i] == 0 and k // num[i] < ans:
		ans = k // num[i]
print(ans)


(n, m) = list(map(int, input().strip().split()))
l = list(map(int, input().strip().split()))
t = []
for i in l:
	if m % i == 0:
		t += [i]
ma = max(t)
print(m // ma)


import sys
import math
import bisect
import itertools

def main():
	(n, m) = map(int, input().split())
	A = list(map(int, input().split()))
	min_val = 10 ** 18
	for a in A:
		if a and m % a == 0:
			val = m // a
			min_val = min(min_val, val)
	print(min_val)
main()


(n, l) = list(map(int, input().split()))
dur = list(map(int, input().split()))
dur.sort(reverse=True)
for i in dur:
	if l % i == 0:
		print(int(l / i))
		break


(n, k) = map(int, input().split())
a = [int(i) for i in input().split()]
ans = 10000000000.0
for i in range(n):
	if k % a[i] == 0 and k // a[i] < ans:
		ans = k // a[i]
print(ans)


(n, k) = map(int, input().split())
l = [int(x) for x in input().split()]
l.sort()
l.reverse()
for i in range(n):
	if k % l[i] == 0:
		print(k // l[i])
		break


X = list(map(int, input().split()))
Water = list(map(int, input().split()))
Water = sorted(Water, reverse=True)
for i in range(X[0]):
	if X[1] % Water[i] == 0:
		print(int(X[1] / Water[i]))
		exit()


(n, k) = map(int, input().split())
print(int(k / max((x for x in list(map(int, input().split())) if not k % x))))


(n, k) = map(int, input().split())
s = reversed(sorted([int(a) for a in input().split()]))

def solve(k, s):
	for a in s:
		if k % a == 0:
			return k // a
print(solve(k, s))


import sys
line = sys.stdin.readline()
vals = line.split()
vnum = int(vals[0])
glength = int(vals[1])
line = sys.stdin.readline()
vals = line.split()
vsizes = []
for val in vals:
	vsizes.append(int(val))
vsizes.sort(reverse=True)
for vsize in vsizes:
	if glength % vsize == 0:
		print(glength // vsize)
		break


(n, k) = map(int, input().split())
ar = list(map(int, input().split()))
i = n - 1
ar.sort()
while True:
	if k % ar[i] == 0:
		break
	i -= 1
print(k // ar[i])


(n, l) = [int(x) for x in input().strip().split()]
A = [int(x) for x in input().strip().split()]
B = []
for x in A:
	if l % x == 0:
		B.append(x)
print(int(l / max(B)))


(bucket_num, length) = map(float, input().split())
buckets = list(map(int, input().split()))
buckets = sorted(buckets)
minimum_hours = 0
for bucket in buckets:
	if length / bucket % 1 == 0:
		minimum_hours = length // bucket
print(int(minimum_hours))


k = int(input().split()[1])
ai = input().split()
result = 0
for item in ai:
	a = int(item)
	if k % a == 0:
		if a > result:
			result = a
print(k // result)


(buckets, garden) = list(map(int, input().split()))
sizes = list(map(int, input().split()))
sizes.sort(reverse=True)
found = False
i = 0
while not found:
	time = garden / sizes[i]
	if time.is_integer():
		found = True
	else:
		i += 1
print(int(time))


(n, k) = input().split()
(n, k) = (int(n), int(k))
M = list(map(int, input().split()))
H = []
for i in M:
	if k % i == 0 and i != 0:
		x = k // i
		H.append(x)
print(min(H))


(n, k) = [int(x) for x in input().split()]
ai = dict(((int(x), True) for x in input().split()))
for i in reversed(range(1, k + 1)):
	if k % i == 0 and i in ai:
		print(k // i)
		exit()


(nbaldes, tamanhojardim) = list(map(int, input().split()))
baldes = list(map(int, input().split()))
baldes.sort()
baldes = baldes[::-1]
achou = False
i = 0
while not achou:
	if tamanhojardim % baldes[i] == 0 and tamanhojardim >= baldes[i]:
		print(int(tamanhojardim / baldes[i]))
		achou = True
	else:
		i += 1


(n, l) = map(int, input().split())
a = []
b = list(map(int, input().split()))
for i in b:
	if l % i == 0:
		a.append(i)
a.sort()
print(int(l / a[len(a) - 1]))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 1000000
for i in range(n):
	if k % a[i] != 0:
		pass
	else:
		ans = min(ans, k // a[i])
print(ans)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
ans = 100000000000
for i in range(n):
	if k % l[i] == 0:
		ans = min(ans, k // l[i])
print(ans)


import math
(n, k) = list(map(int, input().split()))
l = list(map(int, input().split()))
mini = math.inf
for i in l:
	if k % i == 0 and k // i <= mini:
		mini = k // i
print(mini)


inp = input().split(' ')
k = int(inp[1])
inp = input().split(' ')
cb = 0
for bs in inp:
	b = int(bs)
	if b > cb and k % b == 0:
		cb = b
if cb > 0:
	print('{:d}'.format(int(k / cb)))


def main():
	(n, k) = map(int, input().split())
	vecBucks = list(map(int, input().split()))
	vecHours = []
	for i in range(n):
		vecHours.append(waterSegment(vecBucks[i], k))
	print(min(vecHours, default=-1))

def waterSegment(segValue, k):
	usedBuck = 0
	hours = 0
	while usedBuck < k:
		usedBuck += segValue
		hours += 1
	if usedBuck > k:
		return 10000000
	return hours
main()


(x, y) = map(int, input().split())
tab = list(map(int, input().split()))
t = 0
for i in range(len(tab)):
	if y % tab[i] == 0:
		if t == 0:
			max = tab[i]
			t += 1
		elif tab[i] > max and t != 0:
			max = tab[i]
f = y // max
print(f)


(n, k) = map(int, input().split())
res = 10000000000000
for x in map(int, input().split()):
	if k % x == 0 and k // x < res:
		res = k // x
print(res)


(n, k) = map(int, input().split())
cup = list(map(int, input().split()))
cup.sort(reverse=True)
for i in cup:
	w = 0
	while w < k:
		w = w + int(i)
		if w == k:
			print(k // int(i))
			break
	if w == k:
		break


(n, k) = map(int, input().split())
b = list(sorted(map(int, input().split())))
h = 0
for i in b:
	if k % i == 0:
		h = k // i
print(h)


(n, k) = map(int, input().split())
choose = list(map(int, input().split()))
for i in choose:
	if k % i != 0:
		choose[choose.index(i)] = 0
while 0 in choose:
	choose.remove(0)
print(k // max(choose))


(a, b) = map(int, input().split())
x = sorted(list(map(int, input().split())))
for i in range(len(x) - 1, -1, -1):
	if b % x[i] == 0:
		print(b // x[i])
		exit()


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
best = max(filter(lambda x: k % x == 0, a))
print('%d' % (k / best))


import sys
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 10 ** 9
for x in a:
	if k % x == 0:
		ans = min(ans, k // x)
print(ans)


(x, y) = map(int, input().split())
arr = list(map(int, input().split()))
ans = min([y // r for r in arr if y % r == 0])
print(ans)


(x, y) = map(int, input().split())
a = list(map(int, input().split()))
print(min([y // i for i in a if y % i == 0]))


(a, b) = map(int, input().split())
t = list(map(int, input().split()))
maxx = 0
for i in t:
	if b % i == 0 and i > maxx:
		maxx = i
print(b // maxx)


(n, k) = list(map(int, input().split()))
buckets = reversed(sorted(list(map(int, input().split()))))
for i in buckets:
	if k % i == 0:
		print(k // i)
		exit()


inp = input()
inp = inp.split(' ')
inp1 = input()
inp1 = inp1.split(' ')
i = 0
data = []
while i < len(inp1):
	if int(inp[1]) % int(inp1[i]) == 0:
		data.append(int(inp1[i]))
	i = i + 1
j = int(max(data))
print(int(int(inp[1]) / j))


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
m = 100000000000
for i in range(n):
	if k % a[i] == 0 and k // a[i] < m:
		m = k // a[i]
print(m)


(n_buckets, length) = [int(i) for i in input().split()]
buckets = [int(i) for i in input().split()]
buckets.sort()
for i in range(len(buckets) - 1, -1, -1):
	if length % buckets[i] == 0:
		print(int(length / buckets[i]))
		break


(N, K) = [int(i) for i in input().split()]
Buckets = [int(i) for i in input().split()]
Buckets.sort()
Buckets.reverse()
Buckets = list(filter(lambda i: K % i == 0, Buckets))
hrs = []
for i in Buckets:
	hrs.append(K // i)
print(min(hrs))


(n, k) = map(int, input().split())
kl = list(map(int, input().split()))
kl.sort()
for x in range(len(kl) - 1, -1, -1):
	if k % kl[x] == 0:
		print(int(k / kl[x]))
		break


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 2147483647
for i in range(0, n):
	if k % a[i] == 0:
		ans = min(k // a[i], ans)
print(ans)


(k, n) = [int(x) for x in input().split()]
ns = [int(x) for x in input().split()]
b = max([x for x in ns if n % x == 0])
print(n // b)


T = list(map(int, input().split()))
q = list(map(int, input().split()))
count = []
for i in range(T[0]):
	if T[1] % q[i] == 0:
		count.append(int(T[1] / q[i]))
count.sort()
print(count[0])


(n, k) = map(int, input().split())
xs = list(map(int, input().split()))
ans = 0
for x in xs:
	if k % x == 0 and x > ans:
		ans = x
print(k // ans)


(n, k) = [int(x) for x in input().split()]
key = 1
answer = k
i = 0
b = list(map(int, input().split()))
while n > 0:
	a = b[i]
	if k % a == 0 and answer > k / a:
		answer = k / a
	n -= 1
	i += 1
print(int(answer))


entrada = [int(x) for x in input().split()]
baldes = entrada[0]
tamanho = entrada[1]
quantidade = [int(x) for x in input().split()]
final = 0
for i in quantidade:
	if tamanho % i == 0:
		if i > final:
			final = i
resultado = tamanho // final
print(resultado)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
cur = 0
for i in range(n):
	if k % a[i] == 0 and a[i] > cur:
		cur = a[i]
if cur == 0:
	print(k + 1)
else:
	print(k // cur)


a = input()
a = a.split(' ')
n = int(a[0])
k = int(a[1])
d = []
a = input().split(' ')
for i in range(n):
	if k % int(a[i]) == 0:
		d.append(int(a[i]))
d.sort()
print(k // int(d[-1]))


(n1, k1) = input().split()
k = int(k1)
n = int(n1)
arr = list(map(int, input().split()))
for i in range(n):
	if k % max(arr) == 0:
		print(k // max(arr))
		break
	arr.remove(max(arr))


(n, k) = input().split()
mx = 0
n = int(n)
k = int(k)
a = input().split(' ')
for c in a:
	c = int(c)
	if k % c == 0:
		if c > mx:
			mx = c
print(int(k / mx))


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
ans = 0
for i in range(len(a)):
	if k % a[i] == 0:
		ans = max(ans, a[i])
print(int(k / ans))


(n, k) = input().split()
n = int(n)
k = int(k)
baldes = []
baldes = input().split()
for i in range(n):
	baldes[i] = int(baldes[i])
maior = 0
for i in range(n):
	if baldes[i] > maior and k % baldes[i] == 0:
		maior = baldes[i]
if maior != 0:
	print(k // maior)
else:
	print(0)


f = lambda : map(int, input().split())
(n, k) = f()
a = sorted(list(f()))[::-1]
for x in a:
	if k % x == 0:
		print(k // x)
		break


(numBuckets, garLen) = map(int, input().split())
buckets = list(map(int, input().split()))
biggest = 0
for x in buckets:
	if garLen % x == 0 and x > biggest:
		biggest = x
	else:
		pass
print(int(garLen / biggest))


(a, b) = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
s = sorted(l)
for i in range(len(s) - 1, -1, -1):
	if b % s[i] == 0:
		print(b // s[i])
		break


(n, k) = input().split(' ')
a = input().split(' ')
n = int(n)
k = int(k)
y = 1
for x in a:
	if k % int(x) == 0 and int(x) > y:
		y = int(x)
print(k // y)


(n, k) = [int(x) for x in input().split()]
a = sorted([int(x) for x in input().split()])
res = k
for ai in a:
	if k % ai == 0:
		res = min(res, k // ai)
print(res)


(n, k) = map(int, input().split())
buckets = list(map(int, input().split()))
ans = k + 1
for i in range(n):
	if buckets[i] * 2 <= k and k % buckets[i] == 0 or k == buckets[i]:
		ans = min(k // buckets[i], ans)
print(ans)


(n, k) = [int(v) for v in input().split()]
aa = [int(v) for v in input().split()]
print(min((k // a for a in aa if k % a == 0)))


firstLine = input()
secondLine = input()
_firstLine = firstLine.split(' ')
_secondLine = secondLine.split(' ')
minHours = 100000000000.0
gardenLenght = int(_firstLine[1])
for bucket in _secondLine:
	if gardenLenght % int(bucket) == 0:
		hours = gardenLenght // int(bucket)
		if minHours > hours:
			minHours = hours
print(minHours)


(n_buckets, length) = map(int, input().split())
buckets = list(map(int, input().split()))
buckets.sort(reverse=True)
for i in buckets:
	if length % i == 0:
		print(length // i)
		break


(n, l) = [int(s) for s in input().split()]
a = [int(s) for s in input().split()]
x = []
for i in a:
	if l % i == 0:
		x.append(l // i)
print(min(x))


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
l2 = []
for i in l:
	if k % i == 0:
		l2.append(k // i)
print(min(l2))


l1 = [int(x) for x in input().split()]
total = l1[1]
l2 = [int(x) for x in input().split()]
l2.sort(reverse=True)
ans = 1
for x in l2:
	if total % x == 0:
		ans = x
		break
ans = total // ans
print(ans)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort(reverse=True)
for bucket in a:
	if k % bucket == 0:
		print(k // bucket)
		exit(0)


(n, k) = map(int, input().split())
a = [int(a) for a in input().split()]
res = []
i = int()
for i in range(len(a)):
	if k % a[i] == 0:
		res.append(k / a[i])
print(int(min(res)))


vals = input()
vals = vals.strip()
n = int(vals.split()[0])
k = int(vals.split()[1])
bucks = input()
buckets = bucks.strip().split()
minVal = k
for x in range(n):
	if k % int(buckets[x]) == 0:
		minBuck = k / int(buckets[x])
		if minVal > minBuck:
			minVal = minBuck
print(int(minVal))


import math
length = int(input().split(' ')[1])
elems = input().split(' ')
neededhours = math.inf
for elem in elems:
	hour = length / int(elem)
	if (math.floor(hour) == hour) & (hour < neededhours):
		neededhours = hour
print(math.floor(neededhours))


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
a.sort(reverse=True)
for i in a:
	if k % i == 0:
		print(k // i)
		exit(0)


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
ans = []
for i in range(n):
	if m % l[i] == 0:
		ans.append(m // l[i])
print(min(ans))


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
p = []
for i in range(len(l)):
	if k % l[i] == 0:
		p.append(l[i])
r = max(p)
print(int(k / r))


(num_buck, k) = [int(x) for x in input().split()]
nums = [int(num) for num in input().split()]
mx = 0
for i in range(num_buck):
	if k % nums[i] == 0:
		mx = max(mx, nums[i])
print(int(k / mx))


from collections import deque
(n, k) = str(input()).split()
(n, k) = (int(n), int(k))
values = list(map(float, input().split()))
values.sort()
values.reverse()
for value in values:
	if k % value == 0:
		print(int(k / value))
		break


(n, w) = map(int, input().split())
l = list(map(int, input().split()))
p = []
for i in range(n):
	if w % l[i] == 0:
		s = int(w / l[i])
		p.append(s)
print(min(p))


(x, y) = map(int, input().split())
buckets = [int(i) for i in input().split()]
houre = 0
q = 0
for i in buckets:
	if y % i == 0:
		q = i
	if houre == 0:
		houre = q
	elif y / q < y / houre:
		houre = q
z = y / houre
print(int(z))


(N, K) = map(int, input().split())
L = list(map(int, input().split()))
L.sort(reverse=True)
for i in range(N):
	if K % L[i] == 0:
		print(int(K / L[i]))
		break


(n, k) = map(int, input().split())
dms = (divmod(k, int(i)) for i in input().split())
result = min((dm[0] for dm in dms if dm[1] == 0))
print(result)


def main():
	([n, k], a) = (map(int, input().split(' ')), list(map(int, input().split(' '))))
	r = list(map(lambda x: int(k / x), filter(lambda y: k % y == 0, a)))
	print(min(r))
	return True
main()


(n, k) = [int(i) for i in input().split()]
v = [int(z) for z in input().split()]
n = n - 1
resposta = 0
v.sort()
for y in range(n, -1, -1):
	if k % v[y] == 0:
		resposta = int(k / v[y])
		break
print(resposta)


(buckets, garden) = map(int, input().split())
lst = [int(x) for x in input().split()]
ans = []
for i in lst:
	if garden % i == 0:
		ans.append(i)
print(int(garden / max(ans)))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
ans = 0
for i in a:
	if k % i == 0:
		ans = k // i
print(ans)


(n, k) = list(map(lambda e: int(e), input().split(' ')))
buckets = list(map(lambda e: int(e), input().split(' ')))
alternatives = []
for b in buckets:
	mod = k % b
	q = k // b
	if mod == 0:
		alternatives.append(int(k // b))
print(min(alternatives))


read = lambda : map(int, input().split())
(n, k) = read()
ans = k
for a in list(read()):
	if k % a == 0:
		ans = min(ans, k // a)
print(ans)


def main():
	(n, k) = map(int, input().split(' '))
	arr = [int(x) for x in input().split(' ')]
	arr.sort()
	temp = 0
	for i in arr:
		if k % i == 0:
			temp = i
		if i > k:
			break
	print(int(k / temp))
main()


(n, k) = [int(t) for t in input().split()]
a = [-int(t) for t in input().split()]
a.sort()
i = 0
while k % a[i]:
	i += 1
print(-k // a[i])


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 100
for x in a:
	if k % x == 0:
		ans = min(ans, k // x)
print(ans)


(n, k) = list(map(int, input().split()))
arr = list(map(int, input().split()))
max_el = 0
for i in range(n):
	if k % arr[i] == 0:
		if max_el < arr[i]:
			max_el = arr[i]
print(k // max_el)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
b = []
for i in a:
	if k % i == 0:
		b.append(i)
m = b[0]
for i in b:
	if i > m:
		m = i
print(k // m)


(n, k) = map(int, input().split())
buckets = [int(i) for i in input().split()]
possibleBuckets = []
for i in buckets:
	if i <= k and k % i == 0:
		possibleBuckets.append(i)
ans = k / max(possibleBuckets)
print(int(ans))


(n_buckets, garden_len) = map(int, input().split())
buckets = list(map(int, input().split()))
choice = max((b for b in buckets if garden_len % b == 0))
print(garden_len // choice)


(n, k) = [int(a) for a in input().strip().split(' ')]
buckets = [int(a) for a in input().strip().split(' ')]
buckets = sorted(buckets)[::-1]
for b in buckets:
	if k % b == 0:
		print(k // b)
		break


def main():
	(N, K) = map(int, input().split())
	A = map(int, input().split())
	a = sorted(A, reverse=True)
	for i in a:
		if not K % i:
			print(K // i)
			break
main()


(n, m) = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
k = m
for i in range(n):
	if m % l[i] == 0:
		k = min(k, m // l[i])
print(k)


def find_factor(n):
	divisor = []
	for i in range(1, int(n ** (1 / 2)) + 1):
		if n % i == 0:
			divisor.append(i)
			divisor.append(n // i)
	return set(divisor)
(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
a = [i for i in a if i in find_factor(k)]
print(k // max(a))


(n, k) = [int(x) for x in input().split()]
lst = list(map(int, input().split()))
lst.sort(reverse=True)
while len(lst) >= 0:
	if k % lst[0] == 0:
		print(k // lst[0])
		break
	else:
		lst.pop(0)


(n, k) = list(map(int, input().split()))
l = list(map(int, input().split()))
h = 1e+99
for elem in l:
	if not k % elem:
		h = min(h, k // elem)
print(h)


(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
a = list(map(int, input().strip().split(' ')))
list.sort(a, reverse=True)
for j in range(n):
	if k % a[j] == 0:
		print(int(k / a[j]))
		break


min = 101
y = 0
(n, k) = map(int, input().split())
a = [int(x) for x in input().split()]
for i in range(n):
	if k % a[i] == 0:
		y = k // a[i]
		if y < min:
			min = y
print(min)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
ans = 1000000
for i in range(n):
	if k % arr[i] == 0:
		temp = k // arr[i]
		ans = min(temp, ans)
print(ans)


(n, k) = [int(w) for w in input().split()]
list = [int(w) for w in input().split()]
min = 10000000
for i in list:
	if k % i == 0:
		tmp = k / i
		if tmp < min:
			min = tmp
print(int(min))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
maxd = -1
for x in a:
	if k % x == 0:
		maxd = max(maxd, x)
print(k // maxd)


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
ans = 9999999999
for num in a:
	if k % num == 0:
		ans = min(ans, k / num)
print(int(ans))


x = input().split()
n = int(x[0])
k = int(x[1])
ans = 0
x = input().split()
for i in range(n):
	m = int(x[i])
	if k % m == 0:
		dummy = k // m
		if dummy < ans or ans == 0:
			ans = dummy
print(ans)


q = lambda : map(int, input().split())
qi = lambda : int(input())
qs = lambda : input().split()
(n, k) = q()
for i in sorted(q())[::-1]:
	if k % i == 0:
		print(k // i)
		break


(n, k) = map(int, input().split())
a = [int(i) for i in input().split()]
mx = 100000
for i in a:
	if k % i == 0:
		mx = min(mx, k // i)
print(mx)


(n, m) = map(int, input().split())
for i in sorted(list(map(int, input().split())), reverse=True):
	if m % i == 0:
		print(m // i)
		exit()


(n, k) = map(int, input().split())
m = []
m1 = []
m = list(map(int, input().split()))
for i in range(n):
	if k % m[i] == 0:
		m1.append(k / m[i])
print(int(min(m1)))


import math
from sys import stdin
string1 = stdin.readline().strip().split()
string2 = stdin.readline().strip().split()
bucketnumber = int(string1[0])
garden = int(string1[1])
output = garden
for item in string2:
	bucket = int(item)
	if garden % bucket == 0:
		if garden / bucket < output:
			output = garden / bucket
print(int(output))


(n, k) = [int(i) for i in input().split()]
a = [int(i) for i in input().split()]
ans = 10 ** 100
for i in a:
	if k % i == 0 and k // i < ans:
		ans = k // i
print(ans)


(n, k) = map(int, input().strip().split())
arr = [int(v) for v in input().strip().split()]
arr.sort()
ans = 0
arr = arr[::-1]
for el in arr:
	if k % el == 0:
		ans = k // el
		break
print(ans)


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
mt = 10000
for i in range(n):
	q = k // arr[i]
	if q < mt and k % arr[i] == 0:
		mt = q
print(mt)


def main():
	(n, k) = list(map(int, input().split()))
	b = list(map(int, input().split()))
	b.sort(reverse=True)
	for num in b:
		if k % num == 0:
			print(k // num)
			return
main()


(n, k) = map(int, input().split())
li = map(int, input().split())
lo = sorted(li)
for i in range(n):
	m = int(lo[n - i - 1])
	if k % m == 0:
		print(int(k / m))
		break


(n, d) = map(int, input().split())
ar = list(map(int, input().split()))
ar = sorted(ar)
i = n - 1
while i >= 0:
	if d % ar[i] == 0:
		print(d // ar[i])
		break
	i -= 1


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
answer = None
a.sort()
for item in a:
	if k % item == 0:
		answer = k // item
print(answer)


(n, k) = [int(x) for x in input().split()]
b = sorted([int(x) for x in input().split()])
for i in b[::-1]:
	if k % i == 0:
		print(int(k / i))
		break


(n, k) = map(int, input().split())
l = sorted(list(map(int, input().split())))
for i in range(n - 1, -1, -1):
	if k % l[i] == 0:
		print(k // l[i])
		break


(n, k) = map(int, input().split())
all = list(map(int, input().split()))
ma = -1
for i in range(len(all)):
	if k % all[i] == 0 and all[i] > ma:
		m = i
		ma = all[i]
print(k // all[m])


import sys

def main():
	input1 = input().split(' ')
	input2 = input()
	buckets = int(input1[0])
	length = int(input1[1])
	minHour = length
	for char in input2.split(' '):
		if length % int(char) == 0:
			if length / int(char) < minHour:
				minHour = length / int(char)
	print(int(minHour))
main()


(n, k) = [int(x) for x in input().split()]
good = []
for i in [int(x) for x in input().split()]:
	if k % i == 0:
		good.append(i)
print(k // max(good))


import sys
(n, k) = map(int, input().split(' '))
number = [int(i) for i in input().split(' ')]
min = 101
for i in number:
	if k % i == 0 and k // i < min:
		min = k // i
print(min)


(n, k) = [int(i) for i in input().split()]
baldes = [int(i) for i in input().split()]
lista = []
for i in baldes:
	if k % i == 0:
		lista.append(k // i)
lista.sort()
print(lista[0])


(n, k) = map(int, input().split())
a = [int(i) for i in input().split()]
l = []
for i in a:
	if k % i == 0:
		l.append(i)
print(k // max(l))


(n, k) = map(int, input().split())
lst = list(map(int, input().split()))
mx = -1
for i in sorted(lst):
	if k % i == 0:
		mx = i
print((k + mx - 1) // mx)


(n, k) = map(int, input().split())
L = list(map(int, input().split()))
a = max([x for x in L if k % x == 0])
print(k // a)


(n, k) = map(int, input().split())
mn = 111
for x in input().split():
	x = int(x)
	if not k % x:
		mn = min(mn, k // x)
print(mn)


(n, k) = map(int, input().split())
print(k // max(filter(lambda v: k % v == 0, map(int, input().split()))))


(n, k) = [int(z) for z in input().split()]
a = [int(z) for z in input().split()]
a.sort()
for i in range(len(a) - 1, -1, -1):
	if k % a[i] == 0:
		print(k // a[i])
		return


l = list(map(int, input().split(' ')))
t = list(map(int, input().split(' ')))
c = 0
for i in range(l[0]):
	if t[i] <= l[1] and l[1] % t[i] == 0 and (t[i] > c):
		c = t[i]
print(int(l[1] / c))


(n, k) = map(int, input().split())
ans = 99999
p = list(map(int, input().strip().split()))[:n]
for i in p:
	if k % i == 0:
		ans = min(ans, k / i)
print(int(ans))


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
p = []
for i in l:
	if k % i == 0:
		p.append(i)
x = max(p)
print(int(k / x))


(n, k) = map(int, input().split())
print(k // max((ai for ai in map(int, input().split()) if k % ai == 0)))


q = input()
(n, k) = q.split()
a = input()
a = a.split()
list = []
for b in a:
	b = int(b)
	list.append(b)
k = int(k)
res = 10000000
for a in list:
	if k % a == 0 and k / a < res:
		res = k / a
print(int(res))


(n, k) = map(int, input().split())
arr = list(map(int, input().split()))
ans = 1
for i in arr:
	if k % i == 0:
		ans = max(ans, i)
print(k // ans)


i = lambda : map(int, input().split())
(_, k) = i()
print(min((k // x for x in i() if k % x < 1)))


s = input().split(' ')
buckets_n = s[0]
length = int(s[1])
buckets_vol = sorted(map(lambda x: int(x), input().split(' ')), reverse=True)
for b in buckets_vol:
	if b <= length and length % b == 0:
		print(int(length / b))
		break


a = (int(n) for n in input().split(' '))
b = (int(n) for n in input().split(' '))
c = []
for i in a:
	c.append(i)
maxx = 0
for i in b:
	if c[1] % i == 0 and i > maxx:
		maxx = i
ans = int(c[1] / maxx)
print(ans)


(n, k) = map(int, input().split())
a = map(int, input().split())
tmp = 0
for i in a:
	if k % i == 0 and i > tmp:
		tmp = i
print(k // tmp)


def run(k, a):
	a.sort(reverse=True)
	for x in a:
		if k % x == 0:
			return k // x
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
print(run(k, a))


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
a.sort()
for i in range(len(a) - 1, -1, -1):
	nxt = a[i]
	if k % nxt == 0:
		print(k // nxt)
		quit()


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
maxx = 0
for i in range(n):
	if k % a[i] == 0 and a[i] > maxx:
		maxx = a[i]
print(int(k / maxx))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
minTime = 1000
for i in a:
	if k % i == 0 and k / i < minTime:
		minTime = k / i
print(int(minTime))


R = lambda : list(map(int, input().split()))
(n, k) = R()
print(min((k // i if k % i == 0 else k for i in R())))


(s, k) = list(map(int, input().split()))
po = list(map(int, input().split()))
po.sort(reverse=True)
for item in po:
	if k % item == 0:
		print(int(k / item))
		break
	else:
		pass


(n, m) = input().split()
L = input().split()
L = [int(x) for x in L]
m = int(m)
n = int(n)
i = int(m)
while i > 0:
	if m % i == 0:
		if i in L:
			print(int(m / i))
			break
	i -= 1


(n, k) = map(int, input().split())
s = list(map(int, input().split()))
c = 100000
for i in range(n):
	if k % s[i] == 0:
		if c > k // s[i]:
			c = k // s[i]
print(c)


(n, k) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
value = 1000000000000
for i in a:
	if k % i == 0:
		b = int(k / i)
		if value > b:
			value = b
print(value)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
a = input().split(' ')
for i in range(n):
	a[i] = int(a[i])
a.sort()
a.reverse()
for i in range(n):
	if k % a[i] == 0:
		x = k // a[i]
		break
print(x)


(n, k) = map(int, input().split())
a = [int(x) for x in input().split()]
a.sort()
for i in a[::-1]:
	if k % i == 0:
		print(k // i)
		exit(0)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
a.reverse()
for x in range(0, len(a)):
	if k % a[x] == 0:
		print(int(k / a[x]))
		break


(n, k) = [int(x) for x in input().split()]
a = list(map(int, input().split()))
a.sort()
a.reverse()
mina = 100000000000
for i in range(0, len(a)):
	if k % a[i] == 0:
		if mina > k // a[i]:
			mina = k // a[i]
print(mina)


(n, k) = map(int, input().split())
b = map(int, input().split())
c = filter(float.is_integer, map(lambda a: k / a, b))
print(int(min(c)))


file = [*open(0)]
(_, garden) = list(map(int, file[0].split()))
buckets = list(map(int, file[1].split()))
hours = 101
for i in buckets:
	new_hour = garden // i
	if garden % i == 0 and new_hour <= hours:
		hours = new_hour
print(hours)


def main():
	(n, m) = map(int, input().split())
	a = map(int, input().split())
	a = sorted(a, reverse=True)
	ans = None
	for i in a:
		if m % i == 0:
			ans = m // i
			break
	print(ans)
main()


def garden(buckets, k):
	hours = 1000
	for item in buckets:
		if k % item == 0:
			if k / item < hours:
				hours = int(k / item)
	print(hours)
inp = list(map(int, input().split()))
n = inp[0]
k = inp[1]
buckets = list(map(int, input().split()))
garden(buckets, k)


(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
l = list(map(int, input().strip().split(' ')))
while True:
	if k % max(l) == 0:
		print(k // max(l))
		break
	else:
		l.remove(max(l))


from collections import Counter
import sys
(n, k) = map(int, input().split())
list = list(map(int, input().split()))
ans = sys.maxsize
for i in range(0, n):
	if k % list[i] == 0:
		if ans > k / list[i]:
			ans = k / list[i]
print(int(ans))


def get_result():
	(n, k) = input().split()
	n = int(n)
	k = int(k)
	r = input().split()
	for (i, val) in enumerate(r):
		r[i] = int(val)
	r.sort(reverse=True)
	for i in r:
		if k % i == 0:
			return int(k / i)
print(get_result())


l = [int(e) for e in input().split()]
le = [int(e) for e in input().split()]
lst = []
for e in le:
	if l[1] % e == 0:
		lst.append(l[1] // e)
print(min(lst))


(a, b) = map(int, input().split())
c = input()
d = c.split(' ')
list = []
list2 = []
for i in range(0, len(d)):
	if b % int(d[i]) == 0:
		list.append(d[i])
for i in range(0, len(list)):
	list2.append(b / int(list[i]))
print(int(min(list2)))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
mx = k + 1
for c in a:
	if k % c == 0 and k // c < mx:
		mx = k // c
print(mx)


(n, k) = map(int, input().split())
res = float('inf')
for e in map(int, input().split()):
	if k % e == 0:
		res = min(res, k // e)
print(res)


[n, k] = map(int, input().split())
a = list(map(int, input().split()))
hours = [k / x if k % x == 0 else 101 for x in a]
print('%d' % min(hours))


def main():
	(n, k) = map(int, input().split(' '))
	a = list(map(int, input().split(' ')))
	total = 101
	for i in a:
		if k % i == 0:
			if k // i <= total:
				total = k // i
	print(total)
main()


import sys
import math
input = sys.stdin.readline

def inp():
	return int(input())

def inara():
	return list(map(int, input().split()))

def insr():
	s = input()
	return list(s[:len(s) - 1])

def invr():
	return map(int, input().split())
(n, k) = invr()
ara = inara()
ans = k
for num in ara:
	if k % num == 0:
		ans = min(ans, k // num)
print(ans)


(n, k) = map(int, input().split())
l = [*map(int, input().split())]
Min = float('inf')
for i in range(n - 1, -1, -1):
	if k % l[i] == 0 and k // l[i] < Min:
		Min = k // l[i]
print(Min)


(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
hours = []
for i in a:
	if k % i == 0:
		hours.append(k / i)
print(int(min(hours)))


(n, k) = map(int, input().split())
max_ = 0
a = list(map(int, input().split()))
for i in a:
	max_ = max(max_, i) if not k % i else max_
print(int(k / max_))


from sys import stdin as cin
from sys import stdout as cout

def main():
	(n, k) = map(int, cin.readline().split())
	a = list(map(int, cin.readline().split()))
	o = 864236415217
	for i in a:
		if k % i == 0:
			o = min(o, k // i)
	print(o)
main()


(a, b) = map(int, input().split())
print(b // max(filter(lambda x: b % x == 0, map(int, input().split()))))


(n, k) = map(int, input().split())
v = list(map(int, input().split()))
t_min = 10000
for vi in v:
	if k % vi == 0:
		t = k // vi
		if t < t_min:
			t_min = t
print(t_min)


(n, k) = map(int, input().split())
l = list(map(int, input().split()))
ans = 10 ** 9
for elem in l:
	if k % elem == 0 and k // elem < ans:
		ans = k // elem
print(ans)


(n, k) = [int(x) for x in input().split()]
arr = [int(x) for x in input().split()]
max_a = 0
for i in range(n):
	if k % arr[i] == 0:
		if arr[i] > max_a:
			max_a = arr[i]
print(k // max_a)


from sys import stdin
from collections import defaultdict
(n, k) = [int(x) for x in input().split()]
a = {int(x) for x in input().split()}
ans = 0
for i in range(1, k + 1):
	if i in a and k % i == 0:
		ans = k // i
print(ans)


(n, k) = map(int, input().split())
A = list(map(int, input().split()))
ls1 = []
for x in A:
	if k % x == 0:
		ls1.append(k / x)
print(int(min(ls1)))


(a, b) = map(int, input().split())
l = list(filter(lambda x: b % int(x) == 0, input().split()))
m = [b // int(l[x]) for x in range(len(l))]
print(min(m))


a = list(map(int, input().split()))
c = list(map(int, input().split()))
f = []
for i in range(a[0]):
	if a[1] % c[i] == 0 and c[i] <= a[1] or c[i] == 1:
		f.append(c[i])
	else:
		continue
f.sort()
f.reverse()
print(int(a[1] / f[0]) if f != [] else a[1])


cantidades = [int(x) for x in input().split()]
a = [int(i) for i in input().split()]

def divide(s):
	if cantidades[1] % s == 0:
		return True
	else:
		return False
cand = filter(divide, a)
print(cantidades[1] // max(cand))


def main():
	(n, k) = map(int, input().split())
	l_h = 1000
	a = list(map(int, input().split()))
	for ai in a:
		if k % ai == 0 and k / ai < l_h:
			l_h = k / ai
	print(int(l_h))
main()


try:
	import sys
	(x, k) = map(int, input().split(' '))
	lengthList = []
	lengthList = [int(p) for p in input().split(' ') for _ in range(0, x)]
	val = []
	val = [n for n in lengthList if float(k / n).is_integer() == True]
	y = max(val)
	print(int(k / y))
except OSError as err:
	print('OS error: {0}'.format(err))
except ValueError as ex:
	print('Could not convert data to an integer.')
	print('value error: {0}'.format(ex))
except:
	print('Unexpected error:', sys.exc_info()[0])


(n, k) = list(map(int, input().split()))
buckets = list(map(int, input().split()))
buckets.sort()
min_time = 0
for b in buckets:
	if k % b == 0:
		min_time = k // b
print(min_time)


(n, k) = input().split(' ')
n = int(n)
k = int(k)
lista = list(map(int, input().split(' ')))
lista.sort(reverse=True)
for x in lista:
	if k % x == 0:
		print(int(k / x))
		exit(0)


import sys
(n, k) = sys.stdin.readline().strip().split(' ')
a = sys.stdin.readline().strip().split(' ')
a = list(map(int, a))
s = 0
m = 0
n = int(n)
k = int(k)
for i in range(n, 0, -1):
	r = k % a[i - 1]
	if r == 0 and a[i - 1] > m:
		m = a[i - 1]
s = k / m
print(int(s))


temp = [int(x) for x in input().split()]
n = temp[0]
k = temp[1]
a = sorted([int(x) for x in input().split()])
for i in range(n - 1, -1, -1):
	if k % a[i] == 0:
		print(k // a[i])
		break


[n, k] = [int(x) for x in input().split()]
A = [int(x) for x in input().split()]
m = 101
for i in range(n):
	if k % A[i] == 0:
		if k // A[i] < m:
			m = k // A[i]
	i += 1
print(m)


(n, k) = list(map(int, input().split()))
lst = []
for x in input().split():
	lst.append(int(x))
i = 0
for x in lst:
	if k % x == 0:
		i = max(i, x)
print(k // i)


(n, k) = map(int, input().split())
a = sorted(map(int, input().split()))
q = a.pop()
while k % q:
	q = a.pop()
print(k // q)


def sad(k, lst):
	maximum = 0
	for i in range(len(lst)):
		if k % lst[i] == 0 and lst[i] > maximum:
			maximum = lst[i]
	return k // maximum
(N, K) = [int(j) for j in input().split()]
b = [int(x) for x in input().split()]
print(sad(K, b))


(n, k) = map(int, input().split(' '))
b = 0
l = map(int, input().split(' '))
for i in l:
	if (i > b) & (k % i == 0):
		b = i
print(int(k / b))


(n, k) = [int(i) for i in input().split()]
ans = -1
temp_max = 0
inp = [int(i) for i in input().split()]
for i in range(len(inp)):
	if inp[i] > temp_max and k % inp[i] == 0:
		temp_max = inp[i]
		ans = k // inp[i]
print(ans)


def solve():
	(n, k) = map(int, input().split())
	a = list(map(int, input().split()))
	a.sort()
	ans = float('inf')
	for i in a:
		if k % i == 0:
			ans = min(ans, k // i)
	print(ans)

def main():
	t = 1
	for _ in range(t):
		solve()
main()


(a, b) = map(int, input().split())
i = [int(a) for a in input().split()]
i.sort()
i.reverse()
for x in i:
	if b % x == 0:
		s = b // x
		break
print(s)


(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
for x in reversed(a):
	if k % x == 0:
		print(k // x)
		exit()


__author__ = 'Dilshod'
(n, k) = list(map(int, input().split()))
m = list(map(int, input().split()))
m.sort(reverse=True)
for i in range(n):
	if k % m[i] == 0:
		print(k // m[i])
		exit()


(buckets, length) = map(int, input().split())
x = list(map(int, input().split()))
x = sorted(x)
ans = 0
for i in x:
	if length % i == 0:
		ans = length // i
print(ans)


lst = list(map(int, input().split(' ')))
buckets = list(map(int, input().split(' ')))
buckets.sort()
no_of_buckets = lst[0]
length_garden = lst[1]
for i in range(no_of_buckets - 1, -1, -1):
	if length_garden % buckets[i] == 0:
		print(length_garden // buckets[i])
		break


(n, k) = (int(x) for x in input().split())
a = [int(x) for x in input().split()]
import math
p = int(math.sqrt(k) + 1)
b = []
for i in range(1, p):
	if k % i == 0:
		b.append(i)
		b.append(k / i)
b.append(k)
b.sort(reverse=True)
for i in b:
	if i in a:
		print(int(k / i))
		exit()


(k, n) = map(int, input().split())
s = map(int, input().split())
q = 1
for i in s:
	if n % i == 0:
		q = max(q, i)
print(n // q)


(_, k) = map(int, input().split())
a = sorted(list(map(int, input().split())))
res = k
for i in range(len(a)):
	if k % a[i] == 0:
		res = min(res, k // a[i])
print(res)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
a.sort()
for i in range(n - 1, -1, -1):
	if k % a[i] == 0:
		print(k // a[i])
		exit(0)


(n, k) = [int(i) for i in input().split()]
bucks = [int(i) for i in input().split()]
m = 100
for i in bucks:
	if k % i == 0 and k // i < m:
		m = k // i
print(m)


(n, k) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
a.sort()
min_hr = 100000000000000000000
for char in a:
	if k % char == 0 and min_hr > k / char:
		min_hr = int(k / char)
print(min_hr)


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
ans = 111
for v in a:
	if k % v == 0:
		ans = min(ans, k // v)
print(ans)


x = [int(x) for x in input().split()]
list_a = [int(x) for x in input().split()]
n = x[0]
k = x[1]
z = []
for i in list_a:
	if k % i == 0:
		s = k / i
		z.append(int(s))
print(min(z))


(n, k) = map(int, input().split())
b = list(map(int, input().split()))
k = [k // b[i] for i in range(n) if k % b[i] == 0]
print(min(k))


(n, k) = map(int, input().split())
xs = [int(x) for x in input().split()]
print(k // max((x for x in xs if k % x == 0)))


(number_of_buckets, length) = map(int, input().split(' '))
buckets = list(map(int, input().split(' ')))
buckets = sorted(buckets, reverse=True)
for i in range(0, len(buckets)):
	if length % buckets[i] == 0:
		print(length // buckets[i])
		break


(n, k) = [int(i) for i in input().split()]
a = [int(x) for x in input().split()]
ans = int(1000000)
for i in range(n):
	if k % a[i] == 0 and k // a[i] < ans:
		ans = k // a[i]
print(ans)


(n, m) = map(int, input().split())
print(min([m // k for k in map(int, input().split()) if m % k == 0]))


import itertools
from collections import defaultdict
from math import gcd

def main():
	(n, k) = [int(v) for v in input().split()]
	data = [int(v) for v in input().split()]
	print(min([k // d for d in data if k % d == 0]))
main()


s = input().split()
n = int(s[0])
k = int(s[1])
ss = list(map(int, input().split()))
y = 0
for x in ss:
	if k % x == 0 and x > y:
		y = x
print(k // y)


from sys import stdin, stdout

def rdl():
	return stdin.readline().replace('\n', '')

def rds():
	return rdl().split(' ')

def si():
	return list(map(lambda x: int(x), rds()))

def wr(string):
	stdout.write(string)

def main():
	line = si()
	(n, k) = (line[0], line[1])
	buckets = si()
	r = 100000
	for bucket in buckets:
		if k % bucket == 0:
			t = int(k / bucket)
			if t < r:
				r = t
	wr('{}\n'.format(r))
main()


(buckets, length) = map(int, input().split())
data = list(map(int, input().split()))
data.sort(reverse=True)
for element in data:
	if length % element == 0:
		print(length // element)
		break


(n, k) = map(int, input().split())
buckets = list(map(int, input().split()))
buckets.sort(reverse=True)
for b in buckets:
	if k % b == 0:
		print(int(k / b))
		break


def num_of_hours(bucket: int, length: int):
	if length % bucket == 0:
		return length // bucket
	else:
		return None
a = input().split(' ')
length = int(a[1])
no_of_buckets = int(a[0])
list_of_buckets = []
hours = []
buckets = input().split(' ')
for bucket in buckets:
	list_of_buckets.append(int(bucket))
for bucket in list_of_buckets:
	num_of_hrs = num_of_hours(bucket, length)
	if num_of_hrs != None:
		hours.append(num_of_hrs)
lowest = hours[0]
for low in hours:
	if lowest > low:
		lowest = low
print(lowest)


x = input().split()
x2 = input().split()
x[1] = int(x[1])
answer = 0
for i in range(len(x2) - 1, -1, -1):
	x2[i] = int(x2[i])
	if x[1] % x2[i] == 0:
		if answer == 0:
			answer = int(x[1] / x2[i])
		else:
			temp = int(x[1] / x2[i])
			if temp < answer:
				answer = temp
print(int(answer))


def Garden(n, k, a):
	minHrs = k
	for b in a:
		if k % b == 0:
			if minHrs > k / b:
				minHrs = int(k / b)
	return minHrs
(n, k) = [int(x) for x in input().split()]
a = [int(x) for x in input().split()]
print(Garden(n, k, a))


A = input()
A = A.split(' ')
B = input()
B = B.split(' ')
C = []
i = 0
while i < len(B):
	if int(A[1]) % int(B[i]) == 0:
		C.append(int(A[1]) // int(B[i]))
	i += 1
print(min(C))


(n, k) = map(int, input().split())
a = [int(num) for num in input().split()]
mina = k
for i in range(0, len(a)):
	if k % a[i] == 0 and k / a[i] < mina:
		mina = k / a[i]
print(int(mina))


_ = list(map(int, input().split()))
__ = sorted(list(map(int, input().split())))
for ___ in range(_[0] - 1, -1, -1):
	if _[1] % __[___] == 0:
		print(_[1] // __[___])
		break


import sys
(n, p) = map(int, sys.stdin.readline().split())
m = []
x = list(map(int, sys.stdin.readline().split()))
for j in range(0, len(x)):
	if p % x[j] == 0:
		s = p // x[j]
		m.append(s)
print(min(m))


(n, k) = map(int, input().split(' '))
a = list(map(int, input().split(' ')))
out = k
for i in a:
	if k % i == 0 and k // i < out:
		out = k // i
print(out)


temp = list(map(int, input().split()))
k = temp[1]
v = list(map(int, input().split()))
ans = 1000
for i in v:
	if k % i == 0:
		ans = min(ans, int(k / i))
print(ans)


line = input().split()
num_buckets = int(line[0])
length = int(line[1])
ans = 0
line = input().split()
for bucket in line:
	bucket_size = int(bucket)
	if length % bucket_size == 0:
		ans = max(ans, bucket_size)
print(length // ans)


(n, k) = map(int, input().split())
ans = float('inf')
for x in map(int, input().split()):
	if k % x == 0:
		ans = min(ans, k // x)
print(ans)


(k, n) = map(int, input().split())
data = [int(i) for i in input().split()]
best_outcome = 0
for i in data:
	if n % i == 0 and i > best_outcome:
		best_outcome = i
print(n // best_outcome)


(n, k) = tuple(map(int, input().split()))
y = list(map(int, input().split()))
y.sort()
y.sort(reverse=True)
for i in y:
	if k % i == 0:
		print(int(k / i))
		break
	else:
		pass


(n, k) = map(int, input().split())
a = [int(i) for i in input().split()]
d = {}
for i in a:
	if k % i == 0:
		d[i] = k // i
ans = 101
for i in d:
	if d[i] < ans:
		ans = d[i]
print(ans)


(n, k) = [int(x) for x in input().split()]
y = list((int(i) for i in input().split()))
m = 0
for i in y:
	if k % i == 0:
		if i > m:
			m = i
print(int(k / m))


def garden(k, arr):
	arr.sort(reverse=True)
	for i in arr:
		if k % i == 0:
			return k // i
(n, k) = list(map(int, input().split()))
arr = list(map(int, input().split()))
print(garden(k, arr))


(n, k) = map(int, input().split())
a = list(map(int, input().split()))
L = []
for i in range(n):
	if k % a[i] == 0:
		L.append(k // a[i])
min = L[0]
for j in range(1, len(L)):
	if L[j] < min:
		min = L[j]
print(min)


z = []
(x, y) = map(int, input().split())
a = list(map(int, input().split()))
for i in range(x):
	if y % a[i] == 0:
		z.append(int(y / a[i]))
print(min(z))


(n, m) = map(int, input().split())
l = list(map(int, input().split()))
c = 0
for x in range(n):
	if m % l[x] == 0:
		if l[x] > c:
			c = l[x]
print(m // c)


def main():
	[__, l] = [int(_) for _ in input().split()]
	buckets = [int(_) for _ in input().split()]
	buckets = [b for b in buckets if b <= l]
	buckets.sort(reverse=True)
	result = next((l // bucket for bucket in buckets if l % bucket == 0))
	print(result)
main()


def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
a = str(input())
a = a.split()
x = 0
c = int(a[1])
d = str(input())
d = d.split()
for i in d:
	if gcd(int(i), c) == int(i):
		if int(i) > x:
			x = int(i)
print(int(c / x))


(n, k) = map(int, input().split())
v = list(map(int, input().split()))
m = 0
for i in range(n):
	if k % v[i] == 0:
		m = max(m, v[i])
print(k // m)


(n, k) = map(int, input().split())
ans = 1000000090990
a = list(map(int, input().split()))
for i in a:
	if k % i == 0 and k // i < ans:
		ans = k // i
print(ans)


(a, b) = map(int, input().split())
l = list(map(int, input().split()))
c = 0
for i in range(a):
	if b % l[i] == 0 and l[i] > c:
		c = l[i]
print(b // c)