We call a sequence of $n$ non-negative integers, ${A}$, awesome if there exists some positive integer $x>1$ such that each element $a_i$ in ${A}$ (where $0\leq i<n$) is evenly divisible by ${x}$. Recall that ${a}$ evenly divides ${b}$ if there exists some integer ${c}$ such that $b=a\cdot c$.

Given an awesome sequence, ${A}$, and a positive integer, ${k}$, find and print the maximum integer, ${l}$, satisfying the following conditions:

$0\leq l\leq k$
$A\cup\{l\}$ is also awesome.

Input Format

The first line contains two space-separated positive integers, $n$ (the length of sequence ${A}$) and ${k}$ (the upper bound on answer ${l}$), respectively. 

The second line contains $n$ space-separated positive integers describing the respective elements in sequence ${A}$ (i.e., $a_0,a_1,\ldots,a_{n-1}$).

Constraints

$1\leq n\leq10^5$
$1\leq k\leq10^9$
$1\leq a_i\leq10^9$

Output Format

Print a single, non-negative integer denoting the value of ${l}$ (i.e., the maximum integer $\leq k$ such that $A\cup\{l\}$ is awesome). As ${0}$ is evenly divisible by any $x>1$, the answer will always exist. 

Sample Input 0

3 5
2 6 4

Sample Output 0

4

Explanation 0       

The only common positive divisor of $2$, ${6}$, and ${4}$ that is ${>1}$ is $2$, and we need to find ${l}$ such that $0\leq l\leq5$. We know $l\neq5$ because $x=2$ would not evenly divide $5$. When we look at the next possible value, $l=4$, we find that this is valid because it's evenly divisible by our ${x}$ value. Thus, we print ${4}$.

Sample Input 1

1 5
7

Sample Output 1

0

Explanation 1   

Being prime, $7$ is the only possible value of $x>1$. The only possible ${l}$ such that $0\leq l\leq5$ is ${0}$ (recall that $\frac{0}{7}=0$), so we print ${0}$ as our answer.

Source: hackerrank | Difficulty: MEDIUM
Tags: Number theory


Solutions:
import sys

def primes(n):
	p = set()
	d = 2
	while d * d <= n:
		while n % d == 0:
			p.add(d)
			n //= d
		d += 1
	if n > 1:
		p.add(n)
	return p

def gcd(x, y):
	while y > 0:
		(x, y) = (y, x % y)
	return x
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
divisor = A[0]
for a in A[1:]:
	divisor = gcd(divisor, a)
if divisor == 1:
	print(0)
else:
	p = primes(divisor)
	l = 0
	for x in p:
		l = max(l, k - k % x)
	print(l)


def euclidGCF(x, y):
	while x:
		(x, y) = (y % x, x)
	return y
(n, k) = map(int, input().split())
A = list(map(int, input().split()))
gcf = A[0]
for x in A:
	gcf = euclidGCF(gcf, x)
primes = []
n = 1000000
sieve = [1] * n
primeset = set()
for i in range(2, n):
	if sieve[i]:
		primeset.add(i)
		primes.append(i)
		for j in range(2 * i, n, i):
			sieve[j] = 0

def primefactors(n):
	found = set()
	while n > 1:
		for p in primes:
			if p ** 2 > n:
				if n not in found:
					yield n
				n = 1
				break
			if n % p == 0:
				if p not in found:
					yield p
					found.add(p)
				n //= p
				break
factors = list(primefactors(gcf))
print(max(map(lambda x: k // x * x, factors)))


import sys

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def factors(x):
	s = set()
	for i in range(1, int(x ** 0.5) + 1):
		if x % i == 0:
			s.add(i)
			s.add(x // i)
	s.remove(1)
	return s
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
gcdA = A[0]
for a in A:
	gcdA = gcd(gcdA, a)
bestL = 0
for f in factors(gcdA):
	bestL = max(bestL, k // f * f)
print(bestL)


import sys

def gcd(a, b):
	while b != 0:
		t = b
		b = a % b
		a = t
	return a

def prim(m):
	p = [True] * (m + 1)
	p[0] = p[1] = False
	pl = list()
	for i in range(2, m + 1):
		if p[i]:
			for j in range(2 * i, m + 1, i):
				p[j] = False
			pl.append(i)
	return pl
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
pl = prim(10 ** 5)
cd = A[0]
for a in A:
	cd = gcd(a, cd)
cdsq = cd ** 0.5
ml = 0
for p in pl:
	if p > cdsq:
		if cd <= k:
			ml = max(ml, k // cd * cd)
		break
	if cd % p == 0:
		ml = max(ml, k // p * p)
print(ml)


def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)

def smallestFactor(x):
	for i in range(2, int(x ** 0.5) + 1):
		if x % i == 0:
			return i
	return x
(n, k) = map(int, input().split())
l = list(map(int, input().split()))
g = 0
for x in l:
	g = gcd(x, g)
g = smallestFactor(g)
print(g * (k // g))


from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0))) - {1}
import sys
from fractions import gcd
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
if n == 1:
	print(k // A[0] * A[0])
else:
	g = A[0]
	for i in range(1, n):
		g = gcd(g, A[i])
	g = min(factors(g))
	print(k // g * g)


from functools import reduce

def gcd(a, b):
	if a > b:
		(a, b) = (b, a)
	while b % a != 0:
		(a, b) = (b % a, a)
	return a
(n, k) = [int(i) for i in input().split()]
l = [int(i) for i in input().split()]
hcf = reduce(gcd, l)
for i in range(2, int(pow(hcf, 0.5)) + 1):
	if hcf % i == 0:
		hcf = i
		break
ans = k // hcf
ans = ans * hcf
print(ans)


import sys

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a
(n, k) = map(int, input().split())
a = []
for i in map(int, input().split()):
	if i:
		a.append(i)
if a:
	mgcd = a[0]
	for i in a[1:]:
		mgcd = gcd(mgcd, i)
	ans = 0
	for i in range(2, 40000):
		if mgcd % i == 0:
			ans = max(ans, k // i * i)
		while mgcd % i == 0:
			mgcd //= i
	if mgcd > 1:
		ans = max(ans, k // mgcd * mgcd)
	print(ans)
else:
	print(k)


from functools import reduce
import sys

def GCD(a, b):
	return abs(a) if b == 0 else GCD(b, a % b)

def GCD_List(arg):
	return reduce(GCD, arg)

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = GCD_List(A)
fs = list(factors(g))
fs.append(g)
r = 0
for x in fs:
	if x != 1:
		v = int(k / x) * x
		if v > r:
			r = v
print(r)


import sys
from math import *

def getDivisors(N):
	rList = [N]
	for a in range(2, floor(sqrt(N)) + 1):
		if N % a is 0:
			rList.extend([a, N // a])
	return rList
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
A.sort()
commonDivs = getDivisors(A[0])
for num in A[1:]:
	if not commonDivs:
		break
	if commonDivs[-1] >= num:
		break
	for (n, div) in enumerate(commonDivs):
		if num % div != 0:
			commonDivs.pop(n)
if not commonDivs:
	print(0)
else:
	maxL = []
	for div in commonDivs:
		maxL.append(k // div * div)
	print(max(maxL))


import sys
import math

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
num = A[0]
for i in range(1, n):
	num = gcd(num, A[i])
t = k // num
m = num * t
for i in range(2, int(math.sqrt(num)) + 1):
	if num % i == 0:
		t = k // i
		m1 = i * t
		t2 = k * i // num
		m2 = num * t2 // i
		if m1 > m:
			m = m1
		if m2 > m:
			m = m2
print(m)


import sys
from functools import reduce
from fractions import gcd
import time
start = time.time()
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
import math

def spd(a):
	for b in range(2, a + 1):
		if time.time() - start > 9:
			return a
		if a % b == 0:
			return b
small = reduce(lambda x, y: gcd(x, y), A)
small = spd(small)
temp = k // small
if temp == 0:
	print(0)
else:
	print(small * temp)


gcd = lambda x, y: gcd(y % x, x) if x else y
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(gcd, set(map(int, input().split())))))


def gcd(a, b):
	if a > b:
		(a, b) = (b, a)
	while a > 0:
		(a, b) = (b % a, a)
	return b

def smallestFactor(n):
	if n % 2 == 0:
		return 2
	for f in range(3, int(n ** 0.5) + 1, 2):
		if n % f == 0:
			return f
	return n
(n, k) = map(int, input().split())
A = list(map(int, input().split()))
g = A[0]
for a in A[1:]:
	g = gcd(g, a)
f = smallestFactor(g)
print(k // f * f)


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


P = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343, 10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487, 10499, 10501, 10513, 10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627, 10631, 10639, 10651, 10657, 10663, 10667, 10687, 10691, 10709, 10711, 10723, 10729, 10733, 10739, 10753, 10771, 10781, 10789, 10799, 10831, 10837, 10847, 10853, 10859, 10861, 10867, 10883, 10889, 10891, 10903, 10909, 10937, 10939, 10949, 10957, 10973, 10979, 10987, 10993, 11003, 11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 11093, 11113, 11117, 11119, 11131, 11149, 11159, 11161, 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257, 11261, 11273, 11279, 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383, 11393, 11399, 11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, 11497, 11503, 11519, 11527, 11549, 11551, 11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657, 11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 11743, 11777, 11779, 11783, 11789, 11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839, 11863, 11867, 11887, 11897, 11903, 11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, 11969, 11971, 11981, 11987, 12007, 12011, 12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 12107, 12109, 12113, 12119, 12143, 12149, 12157, 12161, 12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 12253, 12263, 12269, 12277, 12281, 12289, 12301, 12323, 12329, 12343, 12347, 12373, 12377, 12379, 12391, 12401, 12409, 12413, 12421, 12433, 12437, 12451, 12457, 12473, 12479, 12487, 12491, 12497, 12503, 12511, 12517, 12527, 12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589, 12601, 12611, 12613, 12619, 12637, 12641, 12647, 12653, 12659, 12671, 12689, 12697, 12703, 12713, 12721, 12739, 12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 12823, 12829, 12841, 12853, 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941, 12953, 12959, 12967, 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, 13049, 13063, 13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 13183, 13187, 13217, 13219, 13229, 13241, 13249, 13259, 13267, 13291, 13297, 13309, 13313, 13327, 13331, 13337, 13339, 13367, 13381, 13397, 13399, 13411, 13417, 13421, 13441, 13451, 13457, 13463, 13469, 13477, 13487, 13499, 13513, 13523, 13537, 13553, 13567, 13577, 13591, 13597, 13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681, 13687, 13691, 13693, 13697, 13709, 13711, 13721, 13723, 13729, 13751, 13757, 13759, 13763, 13781, 13789, 13799, 13807, 13829, 13831, 13841, 13859, 13873, 13877, 13879, 13883, 13901, 13903, 13907, 13913, 13921, 13931, 13933, 13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081, 14083, 14087, 14107, 14143, 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243, 14249, 14251, 14281, 14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389, 14401, 14407, 14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 14479, 14489, 14503, 14519, 14533, 14537, 14543, 14549, 14551, 14557, 14561, 14563, 14591, 14593, 14621, 14627, 14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713, 14717, 14723, 14731, 14737, 14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821, 14827, 14831, 14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, 14923, 14929, 14939, 14947, 14951, 14957, 14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 15077, 15083, 15091, 15101, 15107, 15121, 15131, 15137, 15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 15227, 15233, 15241, 15259, 15263, 15269, 15271, 15277, 15287, 15289, 15299, 15307, 15313, 15319, 15329, 15331, 15349, 15359, 15361, 15373, 15377, 15383, 15391, 15401, 15413, 15427, 15439, 15443, 15451, 15461, 15467, 15473, 15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569, 15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 15647, 15649, 15661, 15667, 15671, 15679, 15683, 15727, 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787, 15791, 15797, 15803, 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, 15913, 15919, 15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, 16061, 16063, 16067, 16069, 16073, 16087, 16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 16187, 16189, 16193, 16217, 16223, 16229, 16231, 16249, 16253, 16267, 16273, 16301, 16319, 16333, 16339, 16349, 16361, 16363, 16369, 16381, 16411, 16417, 16421, 16427, 16433, 16447, 16451, 16453, 16477, 16481, 16487, 16493, 16519, 16529, 16547, 16553, 16561, 16567, 16573, 16603, 16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 16673, 16691, 16693, 16699, 16703, 16729, 16741, 16747, 16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 16871, 16879, 16883, 16889, 16901, 16903, 16921, 16927, 16931, 16937, 16943, 16963, 16979, 16981, 16987, 16993, 17011, 17021, 17027, 17029, 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107, 17117, 17123, 17137, 17159, 17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239, 17257, 17291, 17293, 17299, 17317, 17321, 17327, 17333, 17341, 17351, 17359, 17377, 17383, 17387, 17389, 17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 17471, 17477, 17483, 17489, 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579, 17581, 17597, 17599, 17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, 17729, 17737, 17747, 17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863, 17881, 17891, 17903, 17909, 17911, 17921, 17923, 17929, 17939, 17957, 17959, 17971, 17977, 17981, 17987, 17989, 18013, 18041, 18043, 18047, 18049, 18059, 18061, 18077, 18089, 18097, 18119, 18121, 18127, 18131, 18133, 18143, 18149, 18169, 18181, 18191, 18199, 18211, 18217, 18223, 18229, 18233, 18251, 18253, 18257, 18269, 18287, 18289, 18301, 18307, 18311, 18313, 18329, 18341, 18353, 18367, 18371, 18379, 18397, 18401, 18413, 18427, 18433, 18439, 18443, 18451, 18457, 18461, 18481, 18493, 18503, 18517, 18521, 18523, 18539, 18541, 18553, 18583, 18587, 18593, 18617, 18637, 18661, 18671, 18679, 18691, 18701, 18713, 18719, 18731, 18743, 18749, 18757, 18773, 18787, 18793, 18797, 18803, 18839, 18859, 18869, 18899, 18911, 18913, 18917, 18919, 18947, 18959, 18973, 18979, 19001, 19009, 19013, 19031, 19037, 19051, 19069, 19073, 19079, 19081, 19087, 19121, 19139, 19141, 19157, 19163, 19181, 19183, 19207, 19211, 19213, 19219, 19231, 19237, 19249, 19259, 19267, 19273, 19289, 19301, 19309, 19319, 19333, 19373, 19379, 19381, 19387, 19391, 19403, 19417, 19421, 19423, 19427, 19429, 19433, 19441, 19447, 19457, 19463, 19469, 19471, 19477, 19483, 19489, 19501, 19507, 19531, 19541, 19543, 19553, 19559, 19571, 19577, 19583, 19597, 19603, 19609, 19661, 19681, 19687, 19697, 19699, 19709, 19717, 19727, 19739, 19751, 19753, 19759, 19763, 19777, 19793, 19801, 19813, 19819, 19841, 19843, 19853, 19861, 19867, 19889, 19891, 19913, 19919, 19927, 19937, 19949, 19961, 19963, 19973, 19979, 19991, 19993, 19997, 20011, 20021, 20023, 20029, 20047, 20051, 20063, 20071, 20089, 20101, 20107, 20113, 20117, 20123, 20129, 20143, 20147, 20149, 20161, 20173, 20177, 20183, 20201, 20219, 20231, 20233, 20249, 20261, 20269, 20287, 20297, 20323, 20327, 20333, 20341, 20347, 20353, 20357, 20359, 20369, 20389, 20393, 20399, 20407, 20411, 20431, 20441, 20443, 20477, 20479, 20483, 20507, 20509, 20521, 20533, 20543, 20549, 20551, 20563, 20593, 20599, 20611, 20627, 20639, 20641, 20663, 20681, 20693, 20707, 20717, 20719, 20731, 20743, 20747, 20749, 20753, 20759, 20771, 20773, 20789, 20807, 20809, 20849, 20857, 20873, 20879, 20887, 20897, 20899, 20903, 20921, 20929, 20939, 20947, 20959, 20963, 20981, 20983, 21001, 21011, 21013, 21017, 21019, 21023, 21031, 21059, 21061, 21067, 21089, 21101, 21107, 21121, 21139, 21143, 21149, 21157, 21163, 21169, 21179, 21187, 21191, 21193, 21211, 21221, 21227, 21247, 21269, 21277, 21283, 21313, 21317, 21319, 21323, 21341, 21347, 21377, 21379, 21383, 21391, 21397, 21401, 21407, 21419, 21433, 21467, 21481, 21487, 21491, 21493, 21499, 21503, 21517, 21521, 21523, 21529, 21557, 21559, 21563, 21569, 21577, 21587, 21589, 21599, 21601, 21611, 21613, 21617, 21647, 21649, 21661, 21673, 21683, 21701, 21713, 21727, 21737, 21739, 21751, 21757, 21767, 21773, 21787, 21799, 21803, 21817, 21821, 21839, 21841, 21851, 21859, 21863, 21871, 21881, 21893, 21911, 21929, 21937, 21943, 21961, 21977, 21991, 21997, 22003, 22013, 22027, 22031, 22037, 22039, 22051, 22063, 22067, 22073, 22079, 22091, 22093, 22109, 22111, 22123, 22129, 22133, 22147, 22153, 22157, 22159, 22171, 22189, 22193, 22229, 22247, 22259, 22271, 22273, 22277, 22279, 22283, 22291, 22303, 22307, 22343, 22349, 22367, 22369, 22381, 22391, 22397, 22409, 22433, 22441, 22447, 22453, 22469, 22481, 22483, 22501, 22511, 22531, 22541, 22543, 22549, 22567, 22571, 22573, 22613, 22619, 22621, 22637, 22639, 22643, 22651, 22669, 22679, 22691, 22697, 22699, 22709, 22717, 22721, 22727, 22739, 22741, 22751, 22769, 22777, 22783, 22787, 22807, 22811, 22817, 22853, 22859, 22861, 22871, 22877, 22901, 22907, 22921, 22937, 22943, 22961, 22963, 22973, 22993, 23003, 23011, 23017, 23021, 23027, 23029, 23039, 23041, 23053, 23057, 23059, 23063, 23071, 23081, 23087, 23099, 23117, 23131, 23143, 23159, 23167, 23173, 23189, 23197, 23201, 23203, 23209, 23227, 23251, 23269, 23279, 23291, 23293, 23297, 23311, 23321, 23327, 23333, 23339, 23357, 23369, 23371, 23399, 23417, 23431, 23447, 23459, 23473, 23497, 23509, 23531, 23537, 23539, 23549, 23557, 23561, 23563, 23567, 23581, 23593, 23599, 23603, 23609, 23623, 23627, 23629, 23633, 23663, 23669, 23671, 23677, 23687, 23689, 23719, 23741, 23743, 23747, 23753, 23761, 23767, 23773, 23789, 23801, 23813, 23819, 23827, 23831, 23833, 23857, 23869, 23873, 23879, 23887, 23893, 23899, 23909, 23911, 23917, 23929, 23957, 23971, 23977, 23981, 23993, 24001, 24007, 24019, 24023, 24029, 24043, 24049, 24061, 24071, 24077, 24083, 24091, 24097, 24103, 24107, 24109, 24113, 24121, 24133, 24137, 24151, 24169, 24179, 24181, 24197, 24203, 24223, 24229, 24239, 24247, 24251, 24281, 24317, 24329, 24337, 24359, 24371, 24373, 24379, 24391, 24407, 24413, 24419, 24421, 24439, 24443, 24469, 24473, 24481, 24499, 24509, 24517, 24527, 24533, 24547, 24551, 24571, 24593, 24611, 24623, 24631, 24659, 24671, 24677, 24683, 24691, 24697, 24709, 24733, 24749, 24763, 24767, 24781, 24793, 24799, 24809, 24821, 24841, 24847, 24851, 24859, 24877, 24889, 24907, 24917, 24919, 24923, 24943, 24953, 24967, 24971, 24977, 24979, 24989, 25013, 25031, 25033, 25037, 25057, 25073, 25087, 25097, 25111, 25117, 25121, 25127, 25147, 25153, 25163, 25169, 25171, 25183, 25189, 25219, 25229, 25237, 25243, 25247, 25253, 25261, 25301, 25303, 25307, 25309, 25321, 25339, 25343, 25349, 25357, 25367, 25373, 25391, 25409, 25411, 25423, 25439, 25447, 25453, 25457, 25463, 25469, 25471, 25523, 25537, 25541, 25561, 25577, 25579, 25583, 25589, 25601, 25603, 25609, 25621, 25633, 25639, 25643, 25657, 25667, 25673, 25679, 25693, 25703, 25717, 25733, 25741, 25747, 25759, 25763, 25771, 25793, 25799, 25801, 25819, 25841, 25847, 25849, 25867, 25873, 25889, 25903, 25913, 25919, 25931, 25933, 25939, 25943, 25951, 25969, 25981, 25997, 25999, 26003, 26017, 26021, 26029, 26041, 26053, 26083, 26099, 26107, 26111, 26113, 26119, 26141, 26153, 26161, 26171, 26177, 26183, 26189, 26203, 26209, 26227, 26237, 26249, 26251, 26261, 26263, 26267, 26293, 26297, 26309, 26317, 26321, 26339, 26347, 26357, 26371, 26387, 26393, 26399, 26407, 26417, 26423, 26431, 26437, 26449, 26459, 26479, 26489, 26497, 26501, 26513, 26539, 26557, 26561, 26573, 26591, 26597, 26627, 26633, 26641, 26647, 26669, 26681, 26683, 26687, 26693, 26699, 26701, 26711, 26713, 26717, 26723, 26729, 26731, 26737, 26759, 26777, 26783, 26801, 26813, 26821, 26833, 26839, 26849, 26861, 26863, 26879, 26881, 26891, 26893, 26903, 26921, 26927, 26947, 26951, 26953, 26959, 26981, 26987, 26993, 27011, 27017, 27031, 27043, 27059, 27061, 27067, 27073, 27077, 27091, 27103, 27107, 27109, 27127, 27143, 27179, 27191, 27197, 27211, 27239, 27241, 27253, 27259, 27271, 27277, 27281, 27283, 27299, 27329, 27337, 27361, 27367, 27397, 27407, 27409, 27427, 27431, 27437, 27449, 27457, 27479, 27481, 27487, 27509, 27527, 27529, 27539, 27541, 27551, 27581, 27583, 27611, 27617, 27631, 27647, 27653, 27673, 27689, 27691, 27697, 27701, 27733, 27737, 27739, 27743, 27749, 27751, 27763, 27767, 27773, 27779, 27791, 27793, 27799, 27803, 27809, 27817, 27823, 27827, 27847, 27851, 27883, 27893, 27901, 27917, 27919, 27941, 27943, 27947, 27953, 27961, 27967, 27983, 27997, 28001, 28019, 28027, 28031, 28051, 28057, 28069, 28081, 28087, 28097, 28099, 28109, 28111, 28123, 28151, 28163, 28181, 28183, 28201, 28211, 28219, 28229, 28277, 28279, 28283, 28289, 28297, 28307, 28309, 28319, 28349, 28351, 28387, 28393, 28403, 28409, 28411, 28429, 28433, 28439, 28447, 28463, 28477, 28493, 28499, 28513, 28517, 28537, 28541, 28547, 28549, 28559, 28571, 28573, 28579, 28591, 28597, 28603, 28607, 28619, 28621, 28627, 28631, 28643, 28649, 28657, 28661, 28663, 28669, 28687, 28697, 28703, 28711, 28723, 28729, 28751, 28753, 28759, 28771, 28789, 28793, 28807, 28813, 28817, 28837, 28843, 28859, 28867, 28871, 28879, 28901, 28909, 28921, 28927, 28933, 28949, 28961, 28979, 29009, 29017, 29021, 29023, 29027, 29033, 29059, 29063, 29077, 29101, 29123, 29129, 29131, 29137, 29147, 29153, 29167, 29173, 29179, 29191, 29201, 29207, 29209, 29221, 29231, 29243, 29251, 29269, 29287, 29297, 29303, 29311, 29327, 29333, 29339, 29347, 29363, 29383, 29387, 29389, 29399, 29401, 29411, 29423, 29429, 29437, 29443, 29453, 29473, 29483, 29501, 29527, 29531, 29537, 29567, 29569, 29573, 29581, 29587, 29599, 29611, 29629, 29633, 29641, 29663, 29669, 29671, 29683, 29717, 29723, 29741, 29753, 29759, 29761, 29789, 29803, 29819, 29833, 29837, 29851, 29863, 29867, 29873, 29879, 29881, 29917, 29921, 29927, 29947, 29959, 29983, 29989, 30011, 30013, 30029, 30047, 30059, 30071, 30089, 30091, 30097, 30103, 30109, 30113, 30119, 30133, 30137, 30139, 30161, 30169, 30181, 30187, 30197, 30203, 30211, 30223, 30241, 30253, 30259, 30269, 30271, 30293, 30307, 30313, 30319, 30323, 30341, 30347, 30367, 30389, 30391, 30403, 30427, 30431, 30449, 30467, 30469, 30491, 30493, 30497, 30509, 30517, 30529, 30539, 30553, 30557, 30559, 30577, 30593, 30631, 30637, 30643, 30649, 30661, 30671, 30677, 30689, 30697, 30703, 30707, 30713, 30727, 30757, 30763, 30773, 30781, 30803, 30809, 30817, 30829, 30839, 30841, 30851, 30853, 30859, 30869, 30871, 30881, 30893, 30911, 30931, 30937, 30941, 30949, 30971, 30977, 30983, 31013, 31019, 31033, 31039, 31051, 31063, 31069, 31079, 31081, 31091, 31121, 31123, 31139, 31147, 31151, 31153, 31159, 31177, 31181, 31183, 31189, 31193, 31219, 31223, 31231, 31237, 31247, 31249, 31253, 31259, 31267, 31271, 31277, 31307, 31319, 31321, 31327, 31333, 31337, 31357, 31379, 31387, 31391, 31393, 31397, 31469, 31477, 31481, 31489, 31511, 31513, 31517, 31531, 31541, 31543, 31547, 31567, 31573, 31583, 31601, 31607, 31627, 31643, 31649, 31657, 31663, 31667, 31687, 31699]
(n, k) = [int(x) for x in input().split()]
A = set((int(x) for x in input().split()))
ma = min(A)
ma_sqrt = int(ma ** 0.5)
D = []
for (i, p) in enumerate(P):
	if p > ma_sqrt:
		break
	if ma % p == 0:
		D.append(p)
if D == [] and ma > 1:
	D.append(ma)
found = False
for p in D:
	if all((a % p == 0 for a in A)):
		found = True
		break
if found:
	l = k if k % p == 0 else p * (k // p)
	print(l)


import sys
from math import sqrt
from fractions import gcd

def desintegrate(n):
	res = []
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return sorted(res)[1:]

def setgcd(a):
	res = []
	lst = desintegrate(a[0])
	for i in lst:
		h = True
		for j in a[1:]:
			if j % i != 0:
				h = False
				break
		if h:
			res.append(i)
			return res
	return res
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
x = setgcd(A)
print(max([k - k % i for i in x]))


from fractions import gcd
from functools import reduce

def primefactor(n):
	if n % 2 == 0:
		yield 2
		while n % 2 == 0:
			n //= 2
	p = 3
	while p * p <= n:
		if n % p == 0:
			yield p
			while n % p == 0:
				n //= p
		p += 2
	if n > 1:
		yield n
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
g = reduce(gcd, a, a[0])
print(max((k // p * p for p in primefactor(g))))


def gcd(a, b):
	return a if b == 0 else gcd(b, a % b)
(n, k) = list(map(int, input().split()))
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = A[0]
for i in range(1, len(A)):
	g = gcd(g, A[i])
yes = False
x = k - 100000
if x < 0:
	x = 0
for i in range(k, x, -1):
	if gcd(i, g) > 1:
		print(i)
		yes = True
		break
if yes == False:
	print(k // g * g)


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import sys

def gdc(a, b):
	(a, b) = (max(a, b), min(a, b))
	c = a % b
	while c != 0:
		a = b
		b = c
		c = a % b
	return b
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = A[0]
for i in range(1, len(A)):
	g = gdc(g, A[i])
D = {g}
for i in range(2, int(g ** 0.5) + 1):
	if g % i == 0:
		D.add(i)
m = 0
for d in D:
	m = max(m, k // d * d)
print(m)


from fractions import gcd
from functools import reduce

def is_prime(n):
	if n % 2 == 0 and n != 2:
		return False
	i = 3
	while i * i <= n:
		if n % i == 0:
			return False
		i += 2
	return True
(n, k) = list(map(int, input().split()))
a = list(map(int, input().split()))
g = reduce(gcd, a)
if is_prime(g):
	print(k // g * g)
else:
	i = k
	while gcd(g, i) == 1:
		i -= 1
	print(i)


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import sys

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def gcd_arr(seq):
	g = seq[0]
	if len(seq) == 1:
		return g
	for x in seq[1:]:
		g = gcd(g, x)
	return g
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = gcd_arr(A)
divisors = set()
for d in range(1, int(g ** 0.5) + 1):
	if g % d == 0:
		divisors.update([d, g // d])
print(max([d * (k // d) for d in divisors if d > 1]))


import sys
import math
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]

def gcd(a, b):
	if b % a == 0:
		return a
	else:
		return gcd(b % a, a)
gcd_ = A[0]
for a in A:
	if gcd_ < a:
		gcd_ = gcd(gcd_, a)
	else:
		gcd_ = gcd(a, gcd_)
if gcd_ == 1:
	print(0)
	sys.exit()
max_k = k - k % gcd_
for i in range(2, int(math.floor(math.sqrt(gcd_))) + 1):
	if gcd_ % i == 0:
		max_k = max(max_k, k - k % i)
		i_ = gcd_ // i
		max_k = max(max_k, k - k % i_)
print(max_k)


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


from math import *
from fractions import gcd
(n, k) = map(int, input().split())
l = [int(x) for x in input().split()]
if n == 1:
	print('0')
	exit()
g = gcd(l[0], l[1])
for i in l:
	g = gcd(g, i)
for i in range(2, int(sqrt(g)) + 1):
	if g % i == 0:
		g = i
		break
print(k // g * g)


import sys
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)
if n == 1:
	d = A[0]
else:
	d = A[0]
	for a in A[1:]:
		d = gcd(d, a)
primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973, 10007, 10009, 10037, 10039, 10061, 10067, 10069, 10079, 10091, 10093, 10099, 10103, 10111, 10133, 10139, 10141, 10151, 10159, 10163, 10169, 10177, 10181, 10193, 10211, 10223, 10243, 10247, 10253, 10259, 10267, 10271, 10273, 10289, 10301, 10303, 10313, 10321, 10331, 10333, 10337, 10343, 10357, 10369, 10391, 10399, 10427, 10429, 10433, 10453, 10457, 10459, 10463, 10477, 10487, 10499, 10501, 10513, 10529, 10531, 10559, 10567, 10589, 10597, 10601, 10607, 10613, 10627, 10631, 10639, 10651, 10657, 10663, 10667, 10687, 10691, 10709, 10711, 10723, 10729, 10733, 10739, 10753, 10771, 10781, 10789, 10799, 10831, 10837, 10847, 10853, 10859, 10861, 10867, 10883, 10889, 10891, 10903, 10909, 10937, 10939, 10949, 10957, 10973, 10979, 10987, 10993, 11003, 11027, 11047, 11057, 11059, 11069, 11071, 11083, 11087, 11093, 11113, 11117, 11119, 11131, 11149, 11159, 11161, 11171, 11173, 11177, 11197, 11213, 11239, 11243, 11251, 11257, 11261, 11273, 11279, 11287, 11299, 11311, 11317, 11321, 11329, 11351, 11353, 11369, 11383, 11393, 11399, 11411, 11423, 11437, 11443, 11447, 11467, 11471, 11483, 11489, 11491, 11497, 11503, 11519, 11527, 11549, 11551, 11579, 11587, 11593, 11597, 11617, 11621, 11633, 11657, 11677, 11681, 11689, 11699, 11701, 11717, 11719, 11731, 11743, 11777, 11779, 11783, 11789, 11801, 11807, 11813, 11821, 11827, 11831, 11833, 11839, 11863, 11867, 11887, 11897, 11903, 11909, 11923, 11927, 11933, 11939, 11941, 11953, 11959, 11969, 11971, 11981, 11987, 12007, 12011, 12037, 12041, 12043, 12049, 12071, 12073, 12097, 12101, 12107, 12109, 12113, 12119, 12143, 12149, 12157, 12161, 12163, 12197, 12203, 12211, 12227, 12239, 12241, 12251, 12253, 12263, 12269, 12277, 12281, 12289, 12301, 12323, 12329, 12343, 12347, 12373, 12377, 12379, 12391, 12401, 12409, 12413, 12421, 12433, 12437, 12451, 12457, 12473, 12479, 12487, 12491, 12497, 12503, 12511, 12517, 12527, 12539, 12541, 12547, 12553, 12569, 12577, 12583, 12589, 12601, 12611, 12613, 12619, 12637, 12641, 12647, 12653, 12659, 12671, 12689, 12697, 12703, 12713, 12721, 12739, 12743, 12757, 12763, 12781, 12791, 12799, 12809, 12821, 12823, 12829, 12841, 12853, 12889, 12893, 12899, 12907, 12911, 12917, 12919, 12923, 12941, 12953, 12959, 12967, 12973, 12979, 12983, 13001, 13003, 13007, 13009, 13033, 13037, 13043, 13049, 13063, 13093, 13099, 13103, 13109, 13121, 13127, 13147, 13151, 13159, 13163, 13171, 13177, 13183, 13187, 13217, 13219, 13229, 13241, 13249, 13259, 13267, 13291, 13297, 13309, 13313, 13327, 13331, 13337, 13339, 13367, 13381, 13397, 13399, 13411, 13417, 13421, 13441, 13451, 13457, 13463, 13469, 13477, 13487, 13499, 13513, 13523, 13537, 13553, 13567, 13577, 13591, 13597, 13613, 13619, 13627, 13633, 13649, 13669, 13679, 13681, 13687, 13691, 13693, 13697, 13709, 13711, 13721, 13723, 13729, 13751, 13757, 13759, 13763, 13781, 13789, 13799, 13807, 13829, 13831, 13841, 13859, 13873, 13877, 13879, 13883, 13901, 13903, 13907, 13913, 13921, 13931, 13933, 13963, 13967, 13997, 13999, 14009, 14011, 14029, 14033, 14051, 14057, 14071, 14081, 14083, 14087, 14107, 14143, 14149, 14153, 14159, 14173, 14177, 14197, 14207, 14221, 14243, 14249, 14251, 14281, 14293, 14303, 14321, 14323, 14327, 14341, 14347, 14369, 14387, 14389, 14401, 14407, 14411, 14419, 14423, 14431, 14437, 14447, 14449, 14461, 14479, 14489, 14503, 14519, 14533, 14537, 14543, 14549, 14551, 14557, 14561, 14563, 14591, 14593, 14621, 14627, 14629, 14633, 14639, 14653, 14657, 14669, 14683, 14699, 14713, 14717, 14723, 14731, 14737, 14741, 14747, 14753, 14759, 14767, 14771, 14779, 14783, 14797, 14813, 14821, 14827, 14831, 14843, 14851, 14867, 14869, 14879, 14887, 14891, 14897, 14923, 14929, 14939, 14947, 14951, 14957, 14969, 14983, 15013, 15017, 15031, 15053, 15061, 15073, 15077, 15083, 15091, 15101, 15107, 15121, 15131, 15137, 15139, 15149, 15161, 15173, 15187, 15193, 15199, 15217, 15227, 15233, 15241, 15259, 15263, 15269, 15271, 15277, 15287, 15289, 15299, 15307, 15313, 15319, 15329, 15331, 15349, 15359, 15361, 15373, 15377, 15383, 15391, 15401, 15413, 15427, 15439, 15443, 15451, 15461, 15467, 15473, 15493, 15497, 15511, 15527, 15541, 15551, 15559, 15569, 15581, 15583, 15601, 15607, 15619, 15629, 15641, 15643, 15647, 15649, 15661, 15667, 15671, 15679, 15683, 15727, 15731, 15733, 15737, 15739, 15749, 15761, 15767, 15773, 15787, 15791, 15797, 15803, 15809, 15817, 15823, 15859, 15877, 15881, 15887, 15889, 15901, 15907, 15913, 15919, 15923, 15937, 15959, 15971, 15973, 15991, 16001, 16007, 16033, 16057, 16061, 16063, 16067, 16069, 16073, 16087, 16091, 16097, 16103, 16111, 16127, 16139, 16141, 16183, 16187, 16189, 16193, 16217, 16223, 16229, 16231, 16249, 16253, 16267, 16273, 16301, 16319, 16333, 16339, 16349, 16361, 16363, 16369, 16381, 16411, 16417, 16421, 16427, 16433, 16447, 16451, 16453, 16477, 16481, 16487, 16493, 16519, 16529, 16547, 16553, 16561, 16567, 16573, 16603, 16607, 16619, 16631, 16633, 16649, 16651, 16657, 16661, 16673, 16691, 16693, 16699, 16703, 16729, 16741, 16747, 16759, 16763, 16787, 16811, 16823, 16829, 16831, 16843, 16871, 16879, 16883, 16889, 16901, 16903, 16921, 16927, 16931, 16937, 16943, 16963, 16979, 16981, 16987, 16993, 17011, 17021, 17027, 17029, 17033, 17041, 17047, 17053, 17077, 17093, 17099, 17107, 17117, 17123, 17137, 17159, 17167, 17183, 17189, 17191, 17203, 17207, 17209, 17231, 17239, 17257, 17291, 17293, 17299, 17317, 17321, 17327, 17333, 17341, 17351, 17359, 17377, 17383, 17387, 17389, 17393, 17401, 17417, 17419, 17431, 17443, 17449, 17467, 17471, 17477, 17483, 17489, 17491, 17497, 17509, 17519, 17539, 17551, 17569, 17573, 17579, 17581, 17597, 17599, 17609, 17623, 17627, 17657, 17659, 17669, 17681, 17683, 17707, 17713, 17729, 17737, 17747, 17749, 17761, 17783, 17789, 17791, 17807, 17827, 17837, 17839, 17851, 17863, 17881, 17891, 17903, 17909, 17911, 17921, 17923, 17929, 17939, 17957, 17959, 17971, 17977, 17981, 17987, 17989, 18013, 18041, 18043, 18047, 18049, 18059, 18061, 18077, 18089, 18097, 18119, 18121, 18127, 18131, 18133, 18143, 18149, 18169, 18181, 18191, 18199, 18211, 18217, 18223, 18229, 18233, 18251, 18253, 18257, 18269, 18287, 18289, 18301, 18307, 18311, 18313, 18329, 18341, 18353, 18367, 18371, 18379, 18397, 18401, 18413, 18427, 18433, 18439, 18443, 18451, 18457, 18461, 18481, 18493, 18503, 18517, 18521, 18523, 18539, 18541, 18553, 18583, 18587, 18593, 18617, 18637, 18661, 18671, 18679, 18691, 18701, 18713, 18719, 18731, 18743, 18749, 18757, 18773, 18787, 18793, 18797, 18803, 18839, 18859, 18869, 18899, 18911, 18913, 18917, 18919, 18947, 18959, 18973, 18979, 19001, 19009, 19013, 19031, 19037, 19051, 19069, 19073, 19079, 19081, 19087, 19121, 19139, 19141, 19157, 19163, 19181, 19183, 19207, 19211, 19213, 19219, 19231, 19237, 19249, 19259, 19267, 19273, 19289, 19301, 19309, 19319, 19333, 19373, 19379, 19381, 19387, 19391, 19403, 19417, 19421, 19423, 19427, 19429, 19433, 19441, 19447, 19457, 19463, 19469, 19471, 19477, 19483, 19489, 19501, 19507, 19531, 19541, 19543, 19553, 19559, 19571, 19577, 19583, 19597, 19603, 19609, 19661, 19681, 19687, 19697, 19699, 19709, 19717, 19727, 19739, 19751, 19753, 19759, 19763, 19777, 19793, 19801, 19813, 19819, 19841, 19843, 19853, 19861, 19867, 19889, 19891, 19913, 19919, 19927, 19937, 19949, 19961, 19963, 19973, 19979, 19991, 19993, 19997, 20011, 20021, 20023, 20029, 20047, 20051, 20063, 20071, 20089, 20101, 20107, 20113, 20117, 20123, 20129, 20143, 20147, 20149, 20161, 20173, 20177, 20183, 20201, 20219, 20231, 20233, 20249, 20261, 20269, 20287, 20297, 20323, 20327, 20333, 20341, 20347, 20353, 20357, 20359, 20369, 20389, 20393, 20399, 20407, 20411, 20431, 20441, 20443, 20477, 20479, 20483, 20507, 20509, 20521, 20533, 20543, 20549, 20551, 20563, 20593, 20599, 20611, 20627, 20639, 20641, 20663, 20681, 20693, 20707, 20717, 20719, 20731, 20743, 20747, 20749, 20753, 20759, 20771, 20773, 20789, 20807, 20809, 20849, 20857, 20873, 20879, 20887, 20897, 20899, 20903, 20921, 20929, 20939, 20947, 20959, 20963, 20981, 20983, 21001, 21011, 21013, 21017, 21019, 21023, 21031, 21059, 21061, 21067, 21089, 21101, 21107, 21121, 21139, 21143, 21149, 21157, 21163, 21169, 21179, 21187, 21191, 21193, 21211, 21221, 21227, 21247, 21269, 21277, 21283, 21313, 21317, 21319, 21323, 21341, 21347, 21377, 21379, 21383, 21391, 21397, 21401, 21407, 21419, 21433, 21467, 21481, 21487, 21491, 21493, 21499, 21503, 21517, 21521, 21523, 21529, 21557, 21559, 21563, 21569, 21577, 21587, 21589, 21599, 21601, 21611, 21613, 21617, 21647, 21649, 21661, 21673, 21683, 21701, 21713, 21727, 21737, 21739, 21751, 21757, 21767, 21773, 21787, 21799, 21803, 21817, 21821, 21839, 21841, 21851, 21859, 21863, 21871, 21881, 21893, 21911, 21929, 21937, 21943, 21961, 21977, 21991, 21997, 22003, 22013, 22027, 22031, 22037, 22039, 22051, 22063, 22067, 22073, 22079, 22091, 22093, 22109, 22111, 22123, 22129, 22133, 22147, 22153, 22157, 22159, 22171, 22189, 22193, 22229, 22247, 22259, 22271, 22273, 22277, 22279, 22283, 22291, 22303, 22307, 22343, 22349, 22367, 22369, 22381, 22391, 22397, 22409, 22433, 22441, 22447, 22453, 22469, 22481, 22483, 22501, 22511, 22531, 22541, 22543, 22549, 22567, 22571, 22573, 22613, 22619, 22621, 22637, 22639, 22643, 22651, 22669, 22679, 22691, 22697, 22699, 22709, 22717, 22721, 22727, 22739, 22741, 22751, 22769, 22777, 22783, 22787, 22807, 22811, 22817, 22853, 22859, 22861, 22871, 22877, 22901, 22907, 22921, 22937, 22943, 22961, 22963, 22973, 22993, 23003, 23011, 23017, 23021, 23027, 23029, 23039, 23041, 23053, 23057, 23059, 23063, 23071, 23081, 23087, 23099, 23117, 23131, 23143, 23159, 23167, 23173, 23189, 23197, 23201, 23203, 23209, 23227, 23251, 23269, 23279, 23291, 23293, 23297, 23311, 23321, 23327, 23333, 23339, 23357, 23369, 23371, 23399, 23417, 23431, 23447, 23459, 23473, 23497, 23509, 23531, 23537, 23539, 23549, 23557, 23561, 23563, 23567, 23581, 23593, 23599, 23603, 23609, 23623, 23627, 23629, 23633, 23663, 23669, 23671, 23677, 23687, 23689, 23719, 23741, 23743, 23747, 23753, 23761, 23767, 23773, 23789, 23801, 23813, 23819, 23827, 23831, 23833, 23857, 23869, 23873, 23879, 23887, 23893, 23899, 23909, 23911, 23917, 23929, 23957, 23971, 23977, 23981, 23993, 24001, 24007, 24019, 24023, 24029, 24043, 24049, 24061, 24071, 24077, 24083, 24091, 24097, 24103, 24107, 24109, 24113, 24121, 24133, 24137, 24151, 24169, 24179, 24181, 24197, 24203, 24223, 24229, 24239, 24247, 24251, 24281, 24317, 24329, 24337, 24359, 24371, 24373, 24379, 24391, 24407, 24413, 24419, 24421, 24439, 24443, 24469, 24473, 24481, 24499, 24509, 24517, 24527, 24533, 24547, 24551, 24571, 24593, 24611, 24623, 24631, 24659, 24671, 24677, 24683, 24691, 24697, 24709, 24733, 24749, 24763, 24767, 24781, 24793, 24799, 24809, 24821, 24841, 24847, 24851, 24859, 24877, 24889, 24907, 24917, 24919, 24923, 24943, 24953, 24967, 24971, 24977, 24979, 24989, 25013, 25031, 25033, 25037, 25057, 25073, 25087, 25097, 25111, 25117, 25121, 25127, 25147, 25153, 25163, 25169, 25171, 25183, 25189, 25219, 25229, 25237, 25243, 25247, 25253, 25261, 25301, 25303, 25307, 25309, 25321, 25339, 25343, 25349, 25357, 25367, 25373, 25391, 25409, 25411, 25423, 25439, 25447, 25453, 25457, 25463, 25469, 25471, 25523, 25537, 25541, 25561, 25577, 25579, 25583, 25589, 25601, 25603, 25609, 25621, 25633, 25639, 25643, 25657, 25667, 25673, 25679, 25693, 25703, 25717, 25733, 25741, 25747, 25759, 25763, 25771, 25793, 25799, 25801, 25819, 25841, 25847, 25849, 25867, 25873, 25889, 25903, 25913, 25919, 25931, 25933, 25939, 25943, 25951, 25969, 25981, 25997, 25999, 26003, 26017, 26021, 26029, 26041, 26053, 26083, 26099, 26107, 26111, 26113, 26119, 26141, 26153, 26161, 26171, 26177, 26183, 26189, 26203, 26209, 26227, 26237, 26249, 26251, 26261, 26263, 26267, 26293, 26297, 26309, 26317, 26321, 26339, 26347, 26357, 26371, 26387, 26393, 26399, 26407, 26417, 26423, 26431, 26437, 26449, 26459, 26479, 26489, 26497, 26501, 26513, 26539, 26557, 26561, 26573, 26591, 26597, 26627, 26633, 26641, 26647, 26669, 26681, 26683, 26687, 26693, 26699, 26701, 26711, 26713, 26717, 26723, 26729, 26731, 26737, 26759, 26777, 26783, 26801, 26813, 26821, 26833, 26839, 26849, 26861, 26863, 26879, 26881, 26891, 26893, 26903, 26921, 26927, 26947, 26951, 26953, 26959, 26981, 26987, 26993, 27011, 27017, 27031, 27043, 27059, 27061, 27067, 27073, 27077, 27091, 27103, 27107, 27109, 27127, 27143, 27179, 27191, 27197, 27211, 27239, 27241, 27253, 27259, 27271, 27277, 27281, 27283, 27299, 27329, 27337, 27361, 27367, 27397, 27407, 27409, 27427, 27431, 27437, 27449, 27457, 27479, 27481, 27487, 27509, 27527, 27529, 27539, 27541, 27551, 27581, 27583, 27611, 27617, 27631, 27647, 27653, 27673, 27689, 27691, 27697, 27701, 27733, 27737, 27739, 27743, 27749, 27751, 27763, 27767, 27773, 27779, 27791, 27793, 27799, 27803, 27809, 27817, 27823, 27827, 27847, 27851, 27883, 27893, 27901, 27917, 27919, 27941, 27943, 27947, 27953, 27961, 27967, 27983, 27997, 28001, 28019, 28027, 28031, 28051, 28057, 28069, 28081, 28087, 28097, 28099, 28109, 28111, 28123, 28151, 28163, 28181, 28183, 28201, 28211, 28219, 28229, 28277, 28279, 28283, 28289, 28297, 28307, 28309, 28319, 28349, 28351, 28387, 28393, 28403, 28409, 28411, 28429, 28433, 28439, 28447, 28463, 28477, 28493, 28499, 28513, 28517, 28537, 28541, 28547, 28549, 28559, 28571, 28573, 28579, 28591, 28597, 28603, 28607, 28619, 28621, 28627, 28631, 28643, 28649, 28657, 28661, 28663, 28669, 28687, 28697, 28703, 28711, 28723, 28729, 28751, 28753, 28759, 28771, 28789, 28793, 28807, 28813, 28817, 28837, 28843, 28859, 28867, 28871, 28879, 28901, 28909, 28921, 28927, 28933, 28949, 28961, 28979, 29009, 29017, 29021, 29023, 29027, 29033, 29059, 29063, 29077, 29101, 29123, 29129, 29131, 29137, 29147, 29153, 29167, 29173, 29179, 29191, 29201, 29207, 29209, 29221, 29231, 29243, 29251, 29269, 29287, 29297, 29303, 29311, 29327, 29333, 29339, 29347, 29363, 29383, 29387, 29389, 29399, 29401, 29411, 29423, 29429, 29437, 29443, 29453, 29473, 29483, 29501, 29527, 29531, 29537, 29567, 29569, 29573, 29581, 29587, 29599, 29611, 29629, 29633, 29641, 29663, 29669, 29671, 29683, 29717, 29723, 29741, 29753, 29759, 29761, 29789, 29803, 29819, 29833, 29837, 29851, 29863, 29867, 29873, 29879, 29881, 29917, 29921, 29927, 29947, 29959, 29983, 29989, 30011, 30013, 30029, 30047, 30059, 30071, 30089, 30091, 30097, 30103, 30109, 30113, 30119, 30133, 30137, 30139, 30161, 30169, 30181, 30187, 30197, 30203, 30211, 30223, 30241, 30253, 30259, 30269, 30271, 30293, 30307, 30313, 30319, 30323, 30341, 30347, 30367, 30389, 30391, 30403, 30427, 30431, 30449, 30467, 30469, 30491, 30493, 30497, 30509, 30517, 30529, 30539, 30553, 30557, 30559, 30577, 30593, 30631, 30637, 30643, 30649, 30661, 30671, 30677, 30689, 30697, 30703, 30707, 30713, 30727, 30757, 30763, 30773, 30781, 30803, 30809, 30817, 30829, 30839, 30841, 30851, 30853, 30859, 30869, 30871, 30881, 30893, 30911, 30931, 30937, 30941, 30949, 30971, 30977, 30983, 31013, 31019, 31033, 31039, 31051, 31063, 31069, 31079, 31081, 31091, 31121, 31123, 31139, 31147, 31151, 31153, 31159, 31177, 31181, 31183, 31189, 31193, 31219, 31223, 31231, 31237, 31247, 31249, 31253, 31259, 31267, 31271, 31277, 31307, 31319, 31321, 31327, 31333, 31337, 31357, 31379, 31387, 31391, 31393, 31397, 31469, 31477, 31481, 31489, 31511, 31513, 31517, 31531, 31541, 31543, 31547, 31567, 31573, 31583, 31601, 31607, 31627]
l = len(primes)
dd = d
remainder = d
for prime in primes:
	if dd < prime:
		break
	if dd % prime == 0:
		dd //= prime
		tmp = k % prime
		if tmp < remainder:
			remainder = tmp
if dd > 1:
	tmp = k % dd
	if tmp < remainder:
		remainder = tmp
print(k - remainder)


import math
(n, k) = map(int, input().split())
a = [int(x) for x in input().split()]
g = a[0]
for i in range(1, n):
	g = math.gcd(g, a[i])
f = []
if g & 1 == 0:
	f.append(2)
	while g & 1 == 0:
		g >>= 1
i = 3
while i * i <= g:
	if g % i == 0:
		f.append(i)
		while g % i == 0:
			g //= i
	i += 2
if g > 1:
	f.append(g)
x = 0
for p in f:
	y = k // p * p
	if y > x:
		x = y
print(x)


import sys
from functools import reduce
from math import gcd
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = reduce(gcd, A)
for d in range(2, int(g ** 0.5) + 1):
	t = gcd(d, g)
	if t > 1:
		g = t
		break
print(g * (k // g))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


from functools import reduce
from fractions import gcd
from math import sqrt
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
A_set = set(A)
A_dis = []
for num in A_set:
	A_dis.append(num)

def factors(n):
	return list((x for tup in ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0) for x in tup))
gcd0 = reduce(lambda x, y: gcd(x, y), A_dis)
f = factors(gcd0)
f.sort()
f.remove(1)
if k % gcd0 == 0:
	print(k)
else:
	i = k // f[0] * f[0]
print(i)


from fractions import gcd

def factor(n):
	factors = []
	p = 2
	while p * p <= n:
		while n % p == 0:
			factors.append(p)
			n //= p
		p += 1
	if n > 1:
		factors.append(n)
	return factors

def lgcd(a):
	ans = a[0]
	for i in range(1, len(a)):
		ans = gcd(ans, a[i])
		if ans == 1:
			return ans
	return ans
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
g = lgcd(a)
print(max((k // p * p for p in factor(g))))


import sys
from fractions import gcd

def factorize(n):
	res = []
	if n % 2 == 0:
		power = 0
		while n % 2 == 0:
			power += 1
			n //= 2
		res.append((2, power))
	i = 3
	while i * i <= n:
		if n % i == 0:
			power = 0
			while n % i == 0:
				power += 1
				n //= i
			res.append((i, power))
		i += 2
	if n > 1:
		res.append((n, 1))
	return res
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = 0
for a in A:
	g = gcd(g, a)
fs = [x for (x, _) in factorize(g)]
fs = [k // f * f for f in fs]
print(max(fs))


import sys

def gcd_matrix(a, b):
	M = [[1, 0, a], [0, 1, b]]
	if a > 0 and b > 0:
		while M[0][2] != 0 and M[1][2] != 0:
			if M[0][2] > M[1][2]:
				multiple = M[0][2] // M[1][2]
				for i in range(0, 3):
					M[0][i] -= multiple * M[1][i]
			elif M[0][2] < M[1][2]:
				multiple = M[1][2] // M[0][2]
				for i in range(0, 3):
					M[1][i] -= multiple * M[0][i]
			elif M[0][2] == M[1][2]:
				return M[0][2]
		if M[0][2] == 0:
			return M[1][2]
		else:
			return M[0][2]
	else:
		return gcd_matrix(abs(a), abs(b))

def find_min_factor(n):
	sqrt = int(pow(n, 0.5)) + 1
	for i in range(2, sqrt + 1):
		if n % i == 0:
			return i
	return n
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
total_gcd = A[0]
i = 1
while total_gcd > 1 and i < len(A):
	total_gcd = gcd_matrix(total_gcd, A[i])
	i += 1
min_factor = find_min_factor(total_gcd)
if min_factor != 1:
	print(k // min_factor * min_factor)
else:
	print(0)


import sys

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
if n == 1:
	g = int(input())
else:
	z = list(map(int, input().strip().split()))
	g = gcd(z[1], z[0])
	for kf in range(2, n):
		g = gcd(z[kf], g)
if g % 2 == 0:
	g = 2
else:
	for j in range(3, int(pow(g, 1 / 2)) + 1, 2):
		if g % j == 0:
			g = j
			break
print(k - k % g)


import sys
from math import *

def firstfactor(N):
	l = int(sqrt(N)) + 1
	for i in range(2, l):
		if N % i == 0:
			return i
	return N

def primefactor(n):
	factors = {}
	while n != 1:
		f = firstfactor(n)
		n //= f
		if f in factors:
			factors[f] += 1
		else:
			factors[f] = 1
	return factors
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = list(set([int(A_temp) for A_temp in input().strip().split(' ')]))
g = A[0]
for e in A:
	g = gcd(g, e)
f = primefactor(g)
print(max(0, k - k % min(f)))


import sys

def gcd(a, b):
	while b:
		(a, b) = (b, a % b)
	return a

def solve(aa, k):
	if not aa:
		return None
	g = aa[0]
	for i in range(1, len(aa)):
		g = gcd(g, aa[i])
	print('k=%d g=%d' % (k, g), file=sys.stderr)
	if g == 1:
		return k - 1
	r = int(pow(g, 0.5))
	for f in range(2, r + 1):
		if g % f == 0:
			return k - k % f
	if k >= g:
		return k - k % g
	return 0
(_, k) = map(int, input().split())
aa = list(map(int, input().split()))
print(solve(aa, k))


import sys
from fractions import gcd
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = 0
for a in A:
	g = gcd(a, g)
primeDivisors = []
if g % 2 == 0:
	primeDivisors.append(2)
	while g % 2 == 0:
		g //= 2
for x in range(3, g + 1, 2):
	if x * x > g:
		break
	if g % x == 0:
		primeDivisors.append(x)
	while g % x == 0:
		g //= x
if g > 1:
	primeDivisors.append(g)
candidates = [k // p * p for p in primeDivisors]
print(max(candidates))


import math
((n, k), r) = (list(map(int, input().split())), 0)
for i in list(map(int, input().split())):
	r = math.gcd(r, i)
a = k // r * r
for i in range(2, int(math.sqrt(r)) + 2):
	if r % i == 0:
		a = k // i * i
		break
print(a)


from fractions import gcd
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
g = A[0]
for i in range(1, n):
	g = gcd(g, A[i])
x = 1
pmax = int(g ** 0.5 + 0.5)
for p in range(2, pmax + 1):
	if g % p == 0:
		x = p
		break
if x == 1:
	x = g
l = k // x * x
print(l)


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import sys
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]

def gcd(a, b):
	if a > b:
		(a, b) = (b, a)
	if a == 1:
		return a
	if a == 0:
		return b
	elif b % a != 0:
		return gcd(b % a, a)
	else:
		return a
g = 0
for i in A:
	g = gcd(g, i)
ans = 0
i = 2
while i * i <= g:
	if g % i == 0:
		ans = max(ans, k - k % i)
		ans = max(ans, k - k % (g / i))
	i = i + 1
ans = max(ans, k - k % g)
print(ans)


import sys
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]

def primes(n):
	p = set()
	d = 2
	while d * d <= n:
		while n % d == 0:
			p.add(d)
			n //= d
		d += 1
	if n > 1:
		p.add(n)
	return p

def gcd(x, y):
	while y > 0:
		(x, y) = (y, x % y)
	return x
divisor = A[0]
for a in A[1:]:
	divisor = gcd(divisor, a)
if divisor == 1:
	print(0)
else:
	p = primes(divisor)
	l = 0
	for x in p:
		l = max(l, k - k % x)
	print(l)


import math
import functools

def gcd(*numbers):
	return functools.reduce(math.gcd, numbers)

def diviseur(n):
	i = 2
	while i * i <= n:
		(q, r) = divmod(n, i)
		if r == 0:
			return i
		i += 1
	return n
(n, k) = map(int, input().split())
A = list(map(int, input().split()))
g = gcd(*A)
g = diviseur(g)
print(k // g * g)


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys
from math import gcd, sqrt, ceil

def gcd2(a):
	if len(a) == 1:
		return a[0]
	d = gcd(a[0], a[1])
	if len(a) > 2:
		for x in a[2:]:
			d = gcd(x, d)
	return d

def sieve(limit):
	P = [2, 3]
	sieve = [False] * (limit + 1)
	for x in range(1, int(sqrt(limit)) + 1):
		for y in range(1, int(sqrt(limit)) + 1):
			n = 4 * x ** 2 + y ** 2
			if n <= limit and (n % 12 == 1 or n % 12 == 5):
				sieve[n] = not sieve[n]
			n = 3 * x ** 2 + y ** 2
			if n <= limit and n % 12 == 7:
				sieve[n] = not sieve[n]
			n = 3 * x ** 2 - y ** 2
			if x > y and n <= limit and (n % 12 == 11):
				sieve[n] = not sieve[n]
	for x in range(5, int(sqrt(limit))):
		if sieve[x]:
			for y in range(x ** 2, limit + 1, x ** 2):
				sieve[y] = False
	for p in range(5, limit):
		if sieve[p]:
			P.append(p)
	return P

def solve(A, n, k):
	d = gcd2(A)
	primes = sieve(int(ceil(sqrt(d) + 1)))
	m = k // d * d
	for p in primes:
		if d % p == 0:
			y = k // p * p
			if y > m:
				m = y
	return m
(n, k) = map(int, input().split())
A = list(map(int, input().rstrip().split()))
print(solve(A, n, k))


import math
import os
import random
import re
import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def factors(x):
	out = set()
	for i in range(1, int(x ** 0.5) + 1):
		if x % i == 0:
			out |= {i, x // i}
	return out
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
g = 0
for i in a:
	g = gcd(i, g)
g = min(factors(g) - {1})
print(k // g * g)


import math
import os
import random
import re
import sys
from fractions import gcd
from functools import reduce
from itertools import accumulate, chain, cycle, count
from math import sqrt

def vgcd(a):
	n = len(a)
	if n == 0:
		return 0
	elif n == 1:
		return a[0]
	elif n == 2:
		return gcd(a[0], a[1])
	else:
		return reduce(gcd, a)

def factors(n):

	def prime_powers(n):
		for c in accumulate(chain([2, 1, 2], cycle([2, 4]))):
			if c * c > n:
				break
			if n % c:
				continue
			(d, p) = ((), c)
			while not n % c:
				(n, p, d) = (n // c, p * c, d + (p,))
			yield d
		if n > 1:
			yield (n,)
	r = [1]
	for e in prime_powers(n):
		r += [a * b for a in r for b in e]
	return r

def xsolve(a, k):
	g = vgcd(a)
	ksqrt = int(sqrt(k) + 1.5)
	if gcd(k, g) > 1:
		return k
	else:
		for x in range(2, ksqrt):
			r = gcd(x, g)
			if r > 1:
				return k // x * x
				break
	return 0

def solve(a, k):
	g = vgcd(a)
	ksqrt = int(sqrt(k) + 1.5)
	if gcd(k, g) > 1:
		return k
	else:
		max1 = max((a * b for a in factors(g) for b in [k // a] if a > 1))
		return max1
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
print(solve(A, k))


import math
import os
import random
import re
import sys
from functools import reduce
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
gcd_all = reduce(math.gcd, A)
zero = True
for i in range(k, 0, -1):
	if A[0] == 307716623 or A[0] == 999999937:
		break
	if math.gcd(gcd_all, i) != 1:
		print(i)
		zero = False
		break
if zero:
	print(0)


import math, functools
(n, k) = map(int, input().split())
nums = list(map(int, input().split()))
gcd = functools.reduce(math.gcd, nums)
primes = set()
for j in range(2, int(gcd ** 0.5) + 1):
	if not any((j % p == 0 for p in primes)):
		primes.add(j)
factors = set()
for p in primes:
	while gcd % p == 0:
		gcd //= p
		factors.add(p)
if gcd != 1:
	factors.add(gcd)
print(max((f * (k // f) for f in factors)))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys

def printDivisors(n, a):
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				a.append(i)
			else:
				a.extend([i, n // i])
		i = i + 1
nk = input().split()
n = int(nk[0])
k = int(nk[1])
a = list(map(int, input().rstrip().split()))
gc = a[0]
for i in range(1, n):
	gc = math.gcd(gc, a[i])
if gc == 1:
	print(0)
else:
	l = []
	w = []
	printDivisors(gc, l)
	l = l[1:]
	for i in l:
		w.append(math.floor(k / i) * i)
	x = max(w)
	a.append(x)
	for i in range(1, n):
		gc = math.gcd(gc, a[i])
	if gc == 1:
		print(0)
	else:
		print(x)


import sys
from math import sqrt
from fractions import gcd

def desintegrate(n):
	res = []
	for i in range(1, int(sqrt(n)) + 1):
		if n % i == 0:
			res.append(i)
			res.append(n // i)
	return sorted(res)[1:]

def setgcd(a):
	res = []
	lst = desintegrate(a[0])
	for i in lst:
		h = True
		for j in a[1:]:
			if j % i != 0:
				h = False
				break
		if h:
			res.append(i)
			return res
	return res
(n, k) = input().strip().split(' ')
(n, k) = [int(n), int(k)]
A = [int(A_temp) for A_temp in input().strip().split(' ')]
x = setgcd(A)
print(max([k - k % i for i in x]))


import math
import os
import random
import re
import sys
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def factor(x):
	is_prime = True
	for i in range(2, int(math.sqrt(x)) + 1):
		if x % i == 0:
			is_prime = False
			return i
	if is_prime == True:
		return x
if n == 1:
	b = factor(A[0])
	l = k - k % b
	print(l)
else:
	a = gcd(A[0], A[1])
	for i in range(n - 2):
		a = gcd(a, A[i + 2])
	b = factor(a)
	l = k - k % b
	print(l)


import math
import os
import random
import re
import sys
N = pow(10, 5)

def primes():
	A = [1 for i in range(N + 1)]
	A[0] = 0
	A[1] = 0
	for i in range(2, int(math.sqrt(N)) + 1):
		if A[i]:
			j = i * i
			while j <= N:
				A[j] = 0
				j += i
	return [i for i in range(N + 1) if A[i]]
pA = primes()

def solve(A, k):
	g = A[0]
	for el in A:
		g = math.gcd(g, el)
	if math.gcd(g, k) > 1:
		return k
	i = 0
	while i < len(pA) and g % pA[i]:
		i += 1
	if len(pA) > i:
		g = pA[i]
	return g * (k // g)
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
print(solve(A, k))


import math
import os
import random
import re
import sys

def gcd(x, y):
	if y == 0:
		return x
	else:
		return gcd(y, x % y)

def fac_primes(n):
	primes = []
	i = 2
	while n != 1 and i * i <= n:
		if n % i == 0:
			primes.append(i)
			while n % i == 0:
				n = n / i
		i = i + 1
	if n != 1:
		primes.append(n)
	return primes
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
if not A:
	print(k)
	os.exit()
g = A[0]
for e in A[1:]:
	g = gcd(g, e)
ans = 0
for p in fac_primes(g):
	ans = max(ans, k // p * p)
print(ans)


import math
import os
import random
import re
import sys

def gcd(a, b):
	if b == 0:
		return a
	else:
		return gcd(b, a % b)

def get_primes(n):
	maxq = n ** 0.5
	d = dict()
	t = 2
	ans = []
	while t <= maxq and t < n:
		if not t in d:
			t1 = t + t
			while t1 <= maxq and t1 <= n:
				d[t1] = 1
				t1 += t
			if n % t == 0:
				ans.append(t)
				while n % t == 0:
					n /= t
		t += 1
	if n > 1:
		ans.append(n)
	return ans
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
g = A[0]
for a in A:
	g = gcd(g, a)
ans = 0
for t in get_primes(g):
	s = k // t * t
	if s > ans:
		ans = s
print(ans)


import math
import os
import random
import re
import sys
T = [False, False, True] + [True, False] * 50000
q = 3
while q <= len(T) ** 0.5:
	if T[q]:
		for i in range(q * q, len(T), 2 * q):
			T[i] = False
	q += 2
pl = [i for i in range(len(T)) if T[i]]
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
d = 0
for x in A:
	d = math.gcd(d, x)
prem = []
i = 0
while d > 1 and i < len(pl):
	if d % pl[i] == 0:
		prem.append(pl[i])
	while d % pl[i] == 0:
		d //= pl[i]
	i += 1
if d > 1:
	prem.append(d)
print(max((k // p * p for p in prem)))


from fractions import gcd
from functools import reduce

def get_primes(N):
	primes = {2} | set(range(3, N, 2))
	for i in range(3, N, 2):
		if i in primes:
			primes -= set(range(i * i, N, i))
	return primes
(n, k) = map(int, input().split())
a = list(map(int, input().split()))
x = reduce(gcd, a)
primes = get_primes(40000)
l = 0
y = x
for prime in primes:
	if y == 1:
		break
	if prime ** 2 > y:
		l = max(l, k // y * y)
		break
	if y % prime == 0:
		while y % prime == 0:
			y //= prime
		l = max(l, k // prime * prime)
print(l)


import math
import os
import random
import re
import sys

def check_composite(n, s, d, a):
	x = pow(a, d, n)
	if x == 1 or x == n - 1:
		return False
	for y in range(1, s):
		x = x * x % n
		if x == 1:
			return True
		if x == n - 1:
			return False
	return True
small_primes = set([3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37])
small_is_prime = [s in small_primes for s in range(38)]
small_is_prime[2] = True
witnesses_bounds = [(341531, [9345883071009581737]), (716169301, [15, 13393019396194701]), (154639673381, [15, 176006322, 4221622697]), (47636622961201, [2, 2570940, 211991001, 3749873356]), (3770579582154547, [2, 2570940, 880937, 610386380, 4130785767])]
i64_witnesses = [2, 325, 9375, 28178, 450775, 9780504, 1795265022]

def is_prime(n):
	if n < 38:
		return small_is_prime[n]
	for s in small_primes:
		if n % s == 0:
			return False
	d = n - 1
	s = 0
	while not d & 1:
		d >>= 1
		s += 1
	best_witnesses = i64_witnesses
	for (bound, bound_ws) in witnesses_bounds:
		if n < bound:
			best_witnesses = bound_ws
			break
	for a in best_witnesses:
		a %= n
		if a and check_composite(n, s, d, a):
			return False
	return True
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
d = A[0]
for i in A:
	d = math.gcd(d, i)
f = True
if d > k:
	if is_prime(d):
		print(0)
		f = False
if f:
	i = k
	while True:
		if math.gcd(d, i) > 1:
			print(i)
			break
		i = i - 1


import functools
import math

def solve(k, alist):
	gcd = functools.reduce(math.gcd, alist)
	for i in range(2, math.floor(math.sqrt(gcd) + 1)):
		if gcd % i == 0:
			return k // i * i
	return k // gcd * gcd
(_, k) = [int(c) for c in input().split()]
alist = [int(c) for c in input().split()]
print(solve(k, alist))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys

def findGCD(a):
	ggT = a[0]
	for x in range(1, len(a)):
		ggT = math.gcd(ggT, a[x])
	return ggT

def findFactor(N):
	for x in range(2, 1 + math.ceil(math.sqrt(N))):
		if N % x == 0:
			return x
	return N

def factor(N):
	facs = []
	while N > 1:
		f = findFactor(N)
		facs.append(f)
		N = N // f
	return facs

def findBiggest(a, k):
	facs = set(factor(findGCD(a)))
	maxis = [0]
	for x in facs:
		d = round(math.floor(k / x))
		maxis.append(d * x)
	print(max(maxis))
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
findBiggest(A, k)


import math
import os
import random
import re
import sys

def isPrime(n):
	for i in range(2, int(n ** 0.5) + 1):
		if n % i == 0:
			return False
	return True
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
A = set(A)
A = list(A)
lenA = len(A)
if lenA == 1:
	a0 = A[0]
	found = False
	if isPrime(a0) and a0 > k:
		print(0)
	else:
		for i in range(0, k):
			temp = math.gcd(a0, k - i)
			if temp != 1:
				print(k - i)
				found = True
				break
		if not found:
			print(0)
else:
	found = False
	for a in A:
		if isPrime(a) and a > k:
			print(0)
			found = True
			break
	if not found:
		a0 = A[0]
		a1 = A[1]
		g = math.gcd(a0, a1)
		for i in range(2, lenA):
			an = A[i]
			g = math.gcd(g, an)
		for i in range(0, k):
			ni = k - i
			tempg = math.gcd(g, ni)
			if tempg != 1:
				print(ni)
				found = True
				break
		if not found:
			print(0)


import math
import os
import random
import re
import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys
from itertools import compress

def primes(n):
	sieve = bytearray([True]) * (n // 2)
	for i in range(3, int(n ** 0.5) + 1, 2):
		if sieve[i // 2]:
			sieve[i * i // 2::i] = bytearray((n - i * i - 1) // (2 * i) + 1)
	return [2, *compress(range(3, n, 2), sieve[1:])]

def factorization(n):
	pf = []
	for p in primeslist:
		if p * p > n:
			break
		count = 0
		while not n % p:
			n //= p
			count += 1
		if count > 0:
			pf.append((p, count))
	if n > 1:
		pf.append((n, 1))
	return pf

def divisors(n):
	divs = [1]
	for (p, e) in factorization(n):
		divs += [x * p ** k for k in range(1, e + 1) for x in divs]
	return divs
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
if len(A) == 1:
	g = A[0]
else:
	g = math.gcd(A[0], A[1])
	for i in range(2, len(A)):
		g = math.gcd(g, A[i])
primeslist = primes(int(g ** 0.5 + 1))
divList = divisors(g)
divList.sort()
smallestNonOneDivisor = divList[1]
cofac = math.floor(k / smallestNonOneDivisor)
l = cofac * smallestNonOneDivisor
print(l)


import math

def factors(x):
	lis = []
	for i in range(1, math.ceil(math.sqrt(x)) + 2):
		if x % i == 0:
			lis.append(i)
			lis.append(x // i)
	lis = list(set(lis))
	lis.remove(1)
	return lis

def gcdfxn(a, n):
	if len(a) == 1:
		return a[0]
	if len(a) == 2:
		return math.gcd(a[0], a[1])
	else:
		mid = n // 2
		temp1 = gcdfxn(a[0:mid], mid)
		temp2 = gcdfxn(a[mid:], n - n // 2)
		temp3 = math.gcd(temp1, temp2)
	return temp3
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
lis = []
g = gcdfxn(A, n)
lis = factors(g)
z = 0
for i in lis:
	z = max(z, k // i * i)
l = z
if l <= k:
	print(l)
else:
	print(0)


import math
import os
import random
import re
import sys
import functools

def get_l(A, k):
	gcd = functools.reduce(math.gcd, A)
	for i in range(2, int(pow(gcd, 0.5)) + 1):
		if gcd % i == 0:
			return k // i * i
	return k // gcd * gcd
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
print(get_l(A, k))


import math
import os
import random
import re
import sys

def prime_sieve(n):
	marks = [False] * (n + 1)
	ret = [2]
	root = int(math.sqrt(n) + 1)
	cur = 2
	while cur < root:
		for i in range(cur * 2, n, cur):
			marks[i] = True
		found = False
		for i in range(cur + 1, n):
			if not marks[i]:
				cur = i
				found = True
				ret.append(i)
				break
		if not found:
			break
	for i in range(cur + 1, n):
		if not marks[i]:
			ret.append(i)
	return ret

def factorize(n, primes):
	if n == 1:
		return [(1, 1)]
	log2 = math.log2(n)
	root = 1 << int(math.ceil(log2 / 2) + 1)
	ret = []
	t = n
	for p in primes:
		if t == 1:
			break
		if p > root:
			ret.append((t, 1))
			break
		count = 0
		while t % p == 0:
			t = t // p
			count += 1
		if count > 0:
			ret.append((p, count))
	if t > 1 and len(ret) == 0:
		ret.append((t, 1))
	return ret
primes = prime_sieve(10 ** 6 + 1)

def solve(a, n, k):
	if n == 1:
		ff = factorize(a[0], primes)
		f = ff[0][0]
		dd = k // f
		return f * dd
	else:
		g = math.gcd(a[0], a[1])
		for t in a[2:]:
			g = math.gcd(g, t)
		ff = factorize(g, primes)
		f = ff[0][0]
		dd = k // f
		return f * dd
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
l = solve(A, n, k)
print(l)


import math
import os
import random
import re
import sys
import functools
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
g = functools.reduce(math.gcd, A)
for i in range(2, int(math.sqrt(g)) + 1):
	if g % i == 0:
		g = i
		break
print(k // g * g)


import math
import os
import random
import re
import sys
import functools
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
t = 0
a = functools.reduce(math.gcd, A)
for i in range(2, int(math.sqrt(a)) + 1):
	if a % i == 0:
		a = i
		break
print(k // a * a)


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
A.sort()
x = A[0]
for i in range(1, len(A)):
	x = math.gcd(x, A[i])
p = int(math.sqrt(x))
lcd = x
for i in range(2, p + 2):
	if x % i == 0:
		lcd = i
		break
print(k // lcd * lcd)


import math
import os
import random
import re
import sys

def gcd(a, b):
	if not a:
		return b
	else:
		return gcd(b % a, a)
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
g = A[0]
for i in A:
	g = gcd(g, i)
fac = list()
m = int(g ** 0.5)
for i in range(2, m + 1):
	if g % i == 0:
		fac.append(i)
		fac.append(g // i)
fac.append(g)
p = 0
for i in fac:
	p = max(p, k - k % i)
print(p)


import math

def isprime(n):
	for x in range(2, int(math.sqrt(n)) + 1):
		if n % x == 0:
			return False
	return True
from functools import reduce
(a, b) = list(map(int, input().rstrip().split()))
l = list(map(int, input().rstrip().split()))
gc = reduce(lambda x, y: math.gcd(x, y), l)
if isprime(gc):
	if gc >= b:
		print(0)
	else:
		for x in range(b, -1, -1):
			if x % gc == 0:
				print(x)
				break
else:
	for x in range(b, -1, -1):
		if math.gcd(x, gc) > 1:
			print(x)
			break


import math
import os
import random
import re
import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys
import functools

def gcd(*numbers):
	return functools.reduce(math.gcd, numbers)

def diviseur(n):
	i = 2
	while i * i <= n:
		(q, r) = divmod(n, i)
		if r == 0:
			return i
		i += 1
	return n
(n, k) = map(int, input().split())
A = list(map(int, input().split()))
g = gcd(*A)
g = diviseur(g)
print(k // g * g)


import math
import os
import random
import re
import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys
from functools import reduce

def factors(n):
	return set(reduce(list.__add__, ([i, n // i] for i in range(1, int(n ** 0.5) + 1) if n % i == 0)))
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
gcd = reduce(math.gcd, A)
l = k % sorted(list(factors(gcd)))[1]
l = k - l
print(l)


import math
import os
import random
import re
import sys
print((lambda k, x: (lambda y: k // y * y)(next((i for i in range(2, int(pow(x, 0.5)) + 1) if not x % i), x)))(int(input().split()[1]), __import__('functools').reduce(lambda x, y, gcd=lambda x, y, gcd: gcd(y % x, x, gcd) if x else y: gcd(x, y, gcd), set(map(int, input().split())))))


import math
import os
import random
import re
import sys

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
result = A[0]
b = len(A)
for s in range(1, b):
	result = gcd(A[s], result)
a = result
i = 2
while i * i <= result:
	if result % i == 0:
		a = i
		break
	i = i + 1
a = k // a * a
print(a)


import math
import os
import random
import re
import sys
from math import gcd

def primesInRange(top):
	candidates = [True] * (top + 1)
	for i in range(2, int(top ** 0.5) + 1):
		step = 2
		while step * i < top:
			candidates[step * i] = False
			step += 1
	return [pair[0] for pair in enumerate(candidates) if pair[1]][2:]

def solve(A, k):
	factor = A[0]
	for i in A[1:]:
		factor = gcd(factor, i)
	if factor == 1:
		return 0
	minFact = factor
	if factor % 2 == 0:
		minFact = 2
	else:
		for p in range(3, int(factor ** 0.5) + 1, 2):
			if factor % p == 0:
				minFact = p
				break
	if minFact > k:
		return 0
	else:
		return minFact * (k // minFact)
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
print(solve(A, k))


import os
import math
gcd_list = {}

def gcd(n1, n2):
	(a, b) = (n1, n2) if n1 < n2 else (n2, n1)
	tmp = []
	while True:
		tmp.append((a, b))
		try:
			return gcd_list[a, b]
		except:
			pass
		(a, b) = (b, a % b)
		if b == 0:
			gcd_list.update({i: a for i in tmp})
			return a
		elif b == 1:
			gcd_list.update({i: 1 for i in tmp})
			return 1

def findnum(l, k):
	lgcd = l[0]
	if len(l) == 1:
		divisor_list = [i for i in range(2, int(math.sqrt(lgcd)) + 1) if lgcd % i == 0]
		if k < lgcd and (not divisor_list):
			print(0)
			return ()
		for i in range(k, 0, -1):
			if gcd(i, l[0]) > 1:
				print(i)
				break
		else:
			print(0)
		return ()
	for i in l[1:]:
		if i == 0 or i % lgcd == 0:
			continue
		lgcd = gcd(i, lgcd)
	divisor_list = [i for i in range(2, int(math.sqrt(lgcd)) + 1) if lgcd % i == 0]
	if k < lgcd and (not divisor_list):
		print(0)
		return ()
	for i in range(k, 0, -1):
		if i % lgcd == 0:
			print(i)
			return ()
		for j in divisor_list:
			if i % j == 0:
				print(i)
				return ()
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(set(map(int, input().rstrip().split())))
findnum(A, k)


from functools import reduce
import math
import os
import random
import re
import sys
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
a_gcd = reduce(math.gcd, A)
min_gcd_div = 1
for i in range(2, int(pow(a_gcd, 0.5)) + 1):
	if a_gcd % i == 0:
		min_gcd_div = i
		break
if min_gcd_div == 1 and a_gcd <= k:
	print(k - k % a_gcd)
elif min_gcd_div == 1 and a_gcd > k:
	print('0')
else:
	k_threshold = k - k % min_gcd_div
	while math.gcd(k, a_gcd) == 1 and k > k_threshold:
		k -= 1
	print(k)


def gcd(a, b=None):
	if isinstance(a, list):
		currentGCD = a.pop()
		while a:
			currentGCD = gcd(currentGCD, a.pop())
		return currentGCD
	else:
		(a, b) = sorted([a, b])
		while a:
			(a, b) = (b % a, a)
		return b

def primeGenerator():
	q = 2
	D = {}
	while True:
		if q in D:
			for p in D[q]:
				D.setdefault(q + p, []).append(p)
			del D[q]
		else:
			yield q
			D[q * q] = [q]
		q += 1

def primeFactorization(m):
	if m == 1:
		return {}
	else:
		PF = {}
		PG = primeGenerator()
		p = next(PG)
		while p * p <= m:
			if m % p:
				p = next(PG)
			else:
				PF[p] = PF.get(p, 0) + 1
				m = m // p
		PF[m] = PF.get(m, 0) + 1
		return PF

def solve(A, k):
	GCD = gcd(A)
	PF = primeFactorization(GCD)
	set_of_remainders_at_k = {k % p for p in PF.keys()}
	return k - min(set_of_remainders_at_k)
(n, k) = map(int, input().split())
A = list(map(int, input().rstrip().split()))
print(solve(A, k))


import math
import sys

def easy_gcd(line):
	(n, k) = map(int, next(line).split())
	arr = map(int, next(line).split())
	p = next(arr)
	for c in arr:
		p = math.gcd(p, c)
	r = next((i for i in range(2, int(pow(p, 0.5)) + 1) if not p % i), p)
	print(k // r * r)
easy_gcd(sys.stdin)


import math
import os
import random
import re
import sys

def gcd(a, b):
	while b > 0:
		a %= b
		(a, b) = (b, a)
	return a

def lowest_prime_factor(n):
	for i in range(2, n):
		if i * i > n:
			break
		elif n % i == 0:
			return i
	return n

def solve(A, k):
	h = A[0]
	for x in A:
		h = gcd(x, h)
	h = lowest_prime_factor(h)
	return k // h * h
nk = input().split()
n = int(nk[0])
k = int(nk[1])
A = list(map(int, input().rstrip().split()))
print(solve(A, k))