Problem: Today Pari and Arya are playing a game called Remainders.

Pari chooses two positive integer x and k, and tells Arya k but not x. Arya have to find the value <image>. There are n ancient numbers c1, c2, ..., cn and Pari has to tell Arya <image> if Arya wants. Given k and the ancient values, tell us if Arya has a winning strategy independent of value of x or not. Formally, is it true that Arya can understand the value <image> for any positive integer x?

Note, that <image> means the remainder of x after dividing it by y.

Input

The first line of the input contains two integers n and k (1 ≤ n, k ≤ 1 000 000) — the number of ancient integers and value k that is chosen by Pari.

The second line contains n integers c1, c2, ..., cn (1 ≤ ci ≤ 1 000 000).

Output

Print "Yes" (without quotes) if Arya has a winning strategy independent of value of x, or "No" (without quotes) otherwise.

Examples

Input

4 5
2 3 5 12


Output

Yes


Input

2 7
2 3


Output

No

Note

In the first sample, Arya can understand <image> because 5 is one of the ancient numbers.

In the second sample, Arya can't be sure what <image> is. For example 1 and 7 have the same remainders after dividing by 2 and 3, but they differ in remainders after dividing by 7.

Solution (in PYTHON3):

Solution:
from __future__ import division, print_function
from fractions import Fraction
import sys
import os
from io import BytesIO, IOBase


# from itertools import *
import heapq
from math import gcd, factorial,floor,ceil

from copy import deepcopy
from collections import deque


# from collections import Counter as counter  # Counter(list)  return a dict with {key: count}
# from itertools import combinations as comb # if a = [1,2,3] then print(list(comb(a,2))) -----> [(1, 2), (1, 3), (2, 3)]
# from itertools import permutations as permutate


from bisect import bisect_left as bl
from bisect import bisect_right as br
from bisect import bisect

#==============================================================================================
#fast I/O region
BUFSIZE = 8192


class FastIO(IOBase):
    newlines = 0

    def __init__(self, file):
        self._fd = file.fileno()
        self.buffer = BytesIO()
        self.writable = "x" in file.mode or "r" not in file.mode
        self.write = self.buffer.write if self.writable else None

    def read(self):
        while True:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            if not b:
                break
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines = 0
        return self.buffer.read()

    def readline(self):
        while self.newlines == 0:
            b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
            self.newlines = b.count(b"\n") + (not b)
            ptr = self.buffer.tell()
            self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
        self.newlines -= 1
        return self.buffer.readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.buffer.getvalue())
            self.buffer.truncate(0), self.buffer.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        self.write = lambda s: self.buffer.write(s.encode("ascii"))
        self.read = lambda: self.buffer.read().decode("ascii")
        self.readline = lambda: self.buffer.readline().decode("ascii")


def print(*args, **kwargs):
    """Prints the values to a stream, or to sys.stdout by default."""
    sep, file = kwargs.pop("sep", " "), kwargs.pop("file", sys.stdout)
    at_start = True
    for x in args:
        if not at_start:
            file.write(sep)
        file.write(str(x))
        at_start = False
    file.write(kwargs.pop("end", "\n"))
    if kwargs.pop("flush", False):
        file.flush()


if sys.version_info[0] < 3:
    sys.stdin, sys.stdout = FastIO(sys.stdin), FastIO(sys.stdout)
else:
    sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)

# inp = lambda: sys.stdin.readline().rstrip("\r\n")

#===============================================================================================
### START ITERATE RECURSION ###
from types import GeneratorType
def iterative(f, stack=[]):
  def wrapped_func(*args, **kwargs):
    if stack: return f(*args, **kwargs)
    to = f(*args, **kwargs)
    while True:
      if type(to) is GeneratorType:
        stack.append(to)
        to = next(to)
        continue
      stack.pop()
      if not stack: break
      to = stack[-1].send(to)
    return to
  return wrapped_func
#### END ITERATE RECURSION ####

#===============================================================================================
#some shortcuts

mod = 10**9+7
def inp(): return sys.stdin.readline().rstrip("\r\n") #for fast input
def out(var): sys.stdout.write(str(var))  #for fast output, always take string
def lis(): return list(map(int, inp().split()))
def stringlis(): return list(map(str, inp().split()))
def sep(): return map(int, inp().split())
def strsep(): return map(str, inp().split())
# def graph(vertex): return [[] for i in range(0,vertex+1)]
def zerolist(n): return [0]*n
def nextline(): out("\n")  #as stdout.write always print sring.
def testcase(t):
    for pp in range(t):
        solve(pp)
def printlist(a) :
    for p in range(0,len(a)):
        out(str(a[p]) + ' ')
def google(p):
    print('Case #'+str(p)+': ',end='')
def lcm(a,b): return (a*b)//gcd(a,b)
def power(x, y, p) :
    res = 1     # Initialize result
    x = x % p  # Update x if it is more , than or equal to p
    if (x == 0) :
        return 0
    while (y > 0) :
        if ((y & 1) == 1) : # If y is odd, multiply, x with result
            res = (res * x) % p

        y = y >> 1      # y = y/2
        x = (x * x) % p
    return res
def ncr(n,r): return factorial(n) // (factorial(r) * factorial(max(n - r, 1)))
def isPrime(n) :
    if (n <= 1) : return False
    if (n <= 3) : return True
    if (n % 2 == 0 or n % 3 == 0) : return False
    i = 5
    while(i * i <= n) :
        if (n % i == 0 or n % (i + 2) == 0) :
            return False
        i = i + 6
    return True

#===============================================================================================
# code here ;))
#
# def helper(sieve, num):
#     while(num>0):
#         if(sieve[num]==1):
#             num=num//10
#         else:
#             return False
#     return True
#
# n=int(inp())
# limit=1000001
# sieve=[1]*limit
# sieve[0]=0
# sieve[1]=0
# for i in range(2, (limit//2) +1):
#     if(sieve[i]==1):
#         for j in range(2*i,limit,i):
#             sieve[j]=0
#
# special=[]
# for i in range(2,limit):
#     if(helper(sieve,i)):
#         special.append(i)
# endl= len(special)
# print(special)
# for _i in range(n):
#     s=int(inp())
#     if(s>limit):
#         print(-1)
#         continue
#     else:
#         index=bl(special,s)
#         if(index>=endl):
#             print(-1)
#             continue
#         if(special[index]<=limit):
#             print(special[index])
#             continue
#         else:
#             print(-1)

# n=int(inp())
# for _i in range(n):
#     x,y=input().split()
#     #print(len(x)-x.find('.')-1)
#
#     d2 = 10 ** (len(x) - x.find('.') - 1)
#     d1='9'*len(y)+'0'*(len(x)-x.find('.')-1)
#
#
#     d1=int(d1)
#     d2=int(d2)
#
#     x1=""
#     for i in x:
#         if(i=='.'):
#             continue
#         x1+=i
#
#     n1=int(x1)
#     n2=int(y)
#
#     n1=int(n1)
#     n2=int(n2)
#
#     denominator=lcm(d1,d2)
#     numerator=n1*(denominator//d2)+n2*(denominator//d1)
#
#     gd=gcd(numerator,denominator)
#     print(numerator//gd,end=" ")
#     print(denominator//gd)


limit=1000001
sieve=[1]*limit
sieve[0]=0
sieve[1]=0
for i in range(2, (limit//2) +1):
    if(sieve[i]==1):
        for j in range(2*i,limit,i):
            sieve[j]=0
primes=[]
for i in range(2,limit):
    if(sieve[i]==1):
        primes.append(i)
#print(primes)

n,k=map(int, inp().split())
arr=lis()
flag=0
factors=[]
d=2
index=0
if(k==1):
    # if( 1 in arr):
    #     print("Yes")
    #     exit(0)
    # else:
    #     print("No")
    #     exit(0)
    print("Yes")
    exit(0)

while(k>1 and d*d<=k):
    tempk=0
    while(k%d==0):
        tempk+=1
        k=k//d
    if(tempk>0):
        factors.append(d**tempk)

    d+=1
if(k>1):
    factors.append(k)
#print(factors)
flag=0
for i in factors:
    flag=0
    for j in arr:
        if(j%i==0):
            flag=1
            break
    if(flag==0):
        break
if(flag==0):
    print("No")
else:
    print("Yes")


#testcase(1)
#testcase(int(inp()))