CodeEff/ECCO huggingface dataset:
# Original solution
while 1:
    s1=input().split('"')
    if s1[0]==".":
        break
    s2=input().split('"')
     
    cnt1=0
    cnt2=0
    flag=0
     
    if len(s1)!=len(s2):
        print("DIFFERENT")
    else:
        i=0
        while i<len(s1):
            if s1[i]==s2[i]:
                cnt1+=1
            elif i%2==0:
                print("DIFFERENT")
                flag=1
                break
            else:
                cnt2+=1
                if cnt2>1:
                    print("DIFFERENT")
                    break
            i+=1
                 
        if flag==0 and cnt2==1:
            print("CLOSE")
        if cnt1==len(s1):
            print("IDENTICAL")


# Optimized solution
while 1:
    list1=input().split('"')
    if list1[0]==".":
        break
    list2=input().split('"')
     
    cnt1=0
    cnt2=0
    flag=0
     
    if len(list1)!=len(list2):
        print("DIFFERENT")
    else:
        i=0
        while i<len(list1):
            if list1[i]==list2[i]:
                cnt1+=1
            elif i%2==0:
                print("DIFFERENT")
                flag=1
                break
            else:
                cnt2+=1
                if cnt2>1:
                    print("DIFFERENT")
                    break
            i+=1
                 
        if flag==0 and cnt2==1:
            print("CLOSE")
        if cnt1==len(list1):
            print("IDENTICAL")
# Original solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
a.sort()
g=a[-1]
def gcd(a,b):
  while b:a,b=b,a%b
  return a
for i in a:g=gcd(g,i)
if a[-1]<k or k%g!=0:print("IMPOSSIBLE")
else:print("POSSIBLE")

# Optimized solution
def gcd(a,b):
  while b:a,b=b,a%b
  return a
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
g=a[0]
for i in a[1:]:g=gcd(g,i)
ans="IMPOSSIBLE"
for i in a:
  if k>i:continue
  if abs(k-i)%g==0:ans="POSSIBLE"
print(ans)
# Original solution
def gcd(a,b):
  while b:a,b=b,a%b
  return a
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
g=a[0]
for i in a[1:]:g=gcd(g,i)
ans="IMPOSSIBLE"
for i in a:
  if k>i:continue
  if abs(k-i)%g==0:ans="POSSIBLE"
print(ans)

# Optimized solution
n,k=list(map(int,input().split()))
a=list(map(int,input().split()))
def gcd(a,b):
  while b:a,b=b,a%b
  return a
g=a[0]
for i in a:g=gcd(g,i)
if max(a)>=k and k%g==0:print("POSSIBLE")
else:print("IMPOSSIBLE")
# Original solution
def factor(N):
    ret = []
    i = 2
    while N > 1:
        if N % i == 0:
            ret.append(i)
            N //= i
        else:
            i += 1
    return ret


from collections import Counter


def solve(N, K, As):
    if K > max(As):
        return "IMPOSSIBLE"

    factors = [Counter(factor(a)) for a in As]
    iter = factors[0]
    for f in factors[1:]:
        for k, v in list(iter.items()):
            if k not in f:
                iter[k] = 0
            else:
                iter[k] = min(v, f[k])

    if all([v == 0 for v in list(iter.values())]):
        return "POSSIBLE"
    else:
        d = 1
        for k, v in list(iter.items()):
            if v != 0:
                d *= k ** v
        if K % d == 0:
            return "POSSIBLE"
    return "IMPOSSIBLE"

if __name__ == "__main__":
    N, K = tuple(map(int, input().split(" ")))
    As = list(map(int, input().split(" ")))
    print((solve(N, K, As)))


# Optimized solution
def factor(N):
    ret = []
    i = 2
    while N > 1:
        if N % i == 0:
            ret.append(i)
            N //= i
        else:
            i += 1
    return ret


assert (factor(4) == [2, 2])
assert (factor(2) == [2])
assert (factor(3) == [3])
assert (factor(10) == [2, 5])

from collections import Counter


def solve(N, K, As):
    if K > max(As):
        return "IMPOSSIBLE"
    iter = Counter(factor(min(As)))
    for a in As:
        for k, v in list(iter.items()):
            if a % k != 0:
                iter[k] = 0
            else:
                count = 0
                kk = k
                while a % kk == 0:
                    kk *= k
                    count += 1
                iter[k] = min(v, count)

    if all([v == 0 for v in list(iter.values())]):
        return "POSSIBLE"
    else:
        d = 1
        for k, v in list(iter.items()):
            if v != 0:
                d *= k ** v
        if K % d == 0:
            return "POSSIBLE"
    return "IMPOSSIBLE"


if __name__ == "__main__":
    N, K = tuple(map(int, input().split(" ")))
    As = list(map(int, input().split(" ")))
    print((solve(N, K, As)))
# Original solution
def main():
    n, k = (int(i) for i in input().split())
    a = [int(i) for i in input().split()]
    a.sort()
    diff_min = 10**9 + 7
    for i in range(n-1):
        diff = abs(a[i] - a[i+1])
        diff_min = (min(diff_min,diff) if diff != 0 else diff_min)
    for i in range(n):
        diff_min = (a[i] % diff_min if a[i] % (diff_min) != 0 else diff_min)
    for i in range(n):
        if a[i] - k >= 0 and (a[i] - k)%diff_min == 0:
            print("POSSIBLE")
            break
    else:
        print("IMPOSSIBLE")
if __name__ == '__main__':
    main()

# Optimized solution
def main():
    N, K = (int(i) for i in input().split())
    A = [int(i) for i in input().split()]
    A.sort()
    maxA = A.pop()
    if maxA < K:
        return print("IMPOSSIBLE")
    if N == 1:
        if maxA == K:
            return print("POSSIBLE")
        else:
            return print("IMPOSSIBLE")
    g = A[0]

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

    for a in A[1:]:
        g = gcd(g, a)

    if (maxA - K) % g == 0:
        print("POSSIBLE")
    else:
        print("IMPOSSIBLE")


if __name__ == '__main__':
    main()
# Original solution
import math
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
if max(l) < k:
    print("IMPOSSIBLE")
    exit()

x = l[0]
for i in l:
    x = math.gcd(x,i)

if x == 1:
    print("POSSIBLE")
else:
    for i in l:
        if (k-i)%x == 0:
            print("POSSIBLE")
            exit()
    print("IMPOSSIBLE")



# Optimized solution
import math
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
if max(l) < k:
    print("IMPOSSIBLE")
    exit()

x = l[0]
for i in l:
    x = math.gcd(x,i)

if k%x:
    print("IMPOSSIBLE")
else:
    print("POSSIBLE")
# Original solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

def gcd(n, m) :
    n, m = max(n, m), min(n, m)
    if m == 0 :
        return n
    return gcd(m, n % m)

dis = A[0]
for a in A :
    dis = gcd(dis, a)

for a in A :
    if a < K :
        continue
    if (a - K) % dis == 0 :
        print('POSSIBLE')
        break
else :
    print('IMPOSSIBLE')

# Optimized solution
N, K = list(map(int, input().split()))
A = list(map(int, input().split()))

def gcd(n, m):
    if m == 0:
        return n
    return gcd(m, n % m)

G = A[0]
for a in A:
    G = gcd(G, a)

for a in A:
    if K <= a and (a - K) % G == 0:
        print('POSSIBLE')
        exit()

print('IMPOSSIBLE')
# Original solution
N,K = (int(i) for i in input().split())
li = [int(i) for i in input().split()]

li.sort()
max = li[-1]

while(len(li) > 1):
    v = li[0]
    for i in range(1, len(li)):
        li[i] = li[i]%v
    for _ in range(li.count(0)):
        li.remove(0)
    li.sort()

if K <= max:
    if K%li[0] == max%li[0]:
        print('POSSIBLE')
        exit()

print('IMPOSSIBLE')


# Optimized solution
N,K = (int(i) for i in input().split())
li = [int(i) for i in input().split()]

max = max(li)

b = min(li)
for a in li:
    while True:
        if a%b == 0:
            break
        tb = b
        b = a%b
        a = tb

if K <= max:
    if K%b == max%b:
        print('POSSIBLE')
        exit()

print('IMPOSSIBLE')
# Original solution
import sys
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()
if a[-1] < k:
    print('IMPOSSIBLE')
    sys.exit(0)

seta = set(a)
if k in seta:
    print('POSSIBLE')
    sys.exit(0)

def gojoho(l, s):
    return s if l % s == 0 else gojoho(s, l % s)

koubaisu = gojoho(a[1], a[0])
for i in a:
    koubaisu = gojoho(i, koubaisu)

if k % koubaisu == 0:
    print('POSSIBLE')
else:
    print('IMPOSSIBLE')

# Optimized solution
n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
a.sort()

def f(l, s):
    return s if l % s == 0 else f(s, l % s)

z = f(a[-1], a[0])
for i in a:
    z = f(i, z)
if a[-1] >= k and k % z == 0:
    print('POSSIBLE')
else:
    print('IMPOSSIBLE')
# Original solution
# -*- coding: utf-8 -*-

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, initial=1)
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN =LIST()

# Kがでかいのは論外
if max(aN) < K:
    print('IMPOSSIBLE')
    exit()

# aN全部の最大公約数を取る
base = aN[0]
for i in range(1, N):
    base = gcd(base, aN[i])
if K % base == 0:
    print('POSSIBLE')
else:
    print('IMPOSSIBLE')


# Optimized solution
# -*- coding: utf-8 -*-

import sys, re
from collections import deque, defaultdict, Counter
from math import sqrt, hypot, factorial, pi, sin, cos, radians
if sys.version_info.minor >= 5: from math import gcd
else: from fractions import gcd 
from heapq import heappop, heappush, heapify, heappushpop
from bisect import bisect_left, bisect_right
from itertools import permutations, combinations, product
from operator import itemgetter, mul
from copy import deepcopy
from functools import reduce, partial
from fractions import Fraction
from string import ascii_lowercase, ascii_uppercase, digits

def input(): return sys.stdin.readline().strip()
def ceil(a, b=1): return int(-(-a // b))
def round(x): return int((x*2+1) // 2)
def fermat(x, y, MOD): return x * pow(y, MOD-2, MOD) % MOD
def lcm(x, y): return (x * y) // gcd(x, y)
def lcm_list(nums): return reduce(lcm, nums, 1)
def gcd_list(nums): return reduce(gcd, nums, nums[0])
def INT(): return int(eval(input()))
def MAP(): return list(map(int, input().split()))
def LIST(): return list(map(int, input().split()))
sys.setrecursionlimit(10 ** 9)
INF = float('inf')
MOD = 10 ** 9 + 7

N, K = MAP()
aN =LIST()

# Kがでかいのは論外
if max(aN) < K:
    print('IMPOSSIBLE')
    exit()

# aN全部の最大公約数を取る
base = gcd_list(aN)
if K % base == 0:
    print('POSSIBLE')
else:
    print('IMPOSSIBLE')
# Original solution
N, K = list(map(int, input().split())) 

A = list(map(int, input().split()))

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

S_possible = "POSSIBLE"
S_impossible = "IMPOSSIBLE"

if N == 1:
    if K == A[0]:
        print(S_possible)
    else:
        print(S_impossible)
else:
    gcd_max = gcd(A[0], A[1])
    for i in range(N-1):
        gcd_current = gcd(A[i], A[i+1])
        if gcd_current < gcd_max:
            gcd_max = gcd_current
    if K % gcd_max == 0 and K <= max(A):
        print(S_possible)
    else:
        print(S_impossible)


# Optimized solution
N, K = list(map(int, input().split())) 

A = list(map(int, input().split()))

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

S_possible = "POSSIBLE"
S_impossible = "IMPOSSIBLE"

b = 0

for a in A:
    b = gcd(a, b)

if K % b or K > max(A):
    print(S_impossible)
else:
    print(S_possible)
# Original solution
def findGCD(a:int, b:int) -> int:
    # バリデーション　a,bは0以上
    if a <= 0:
        raise ValueError("aは0より大きくなければいけません。(a:{})".format(a))
    elif b <= 0:
        raise ValueError("bは0より大きくなければいけません。(b:{})".format(b))
    
    # ユークリッドの互除法
    while 1:
        if a%b == 0:
            return b
        else:
            a = a%b
        
        if b%a == 0:
            return a
        else:
            b = b%a
            
from functools import reduce

n,k = list(map(int, input().split()))
a = list(map(int, input().split()))


gcd = reduce(findGCD, a)

if k % gcd == 0 and k <= max(a):
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")

# Optimized solution
def findGCD(a:int, b:int) -> int:
    # ユークリッドの互除法
    while 1:
        if a%b == 0:
            return b
        else:
            a = a%b
        
        if b%a == 0:
            return a
        else:
            b = b%a
            
from functools import reduce

n,k = list(map(int, input().split()))
a = list(map(int, input().split()))


gcd = reduce(findGCD, a)

if k % gcd == 0 and k <= max(a):
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")
# Original solution
n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
ans = 0
if k in l:
    print("POSSIBLE")
    exit()
if n == 1:
    l[0] == k

la = []
while True:
    for i in range(n):
        x = l[i] - k
        xx = l[i] + k
        if x in l or xx in l :
            ans = 1
            break
        else:
            if x not in la:
                la.append(x)
            if xx not in la:
                la.append(x)
        for j in range(i,n):
            a = abs(l[j] - l[i])
            if a == k:
                ans = 1
                break
            else:
                if a in la:
                    ans = 1
                    break
                if a not in l:
                    l.append(a)
                x = a - k
                xx = a + k
                if x in l or xx in l :
                    ans = 1
                    break
                else:
                    if x not in la:
                        la.append(x)
                    if xx not in la:
                        la.append(x)

    _n = n
    n = len(l)
    if n == _n:
        break

if ans == 1:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")

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

n,k = list(map(int,input().split()))
l = list(map(int,input().split()))
m = max(l)
for i in range(1,n):
    l[i] = gcd(max(l[i],l[i-1]),min(l[i],l[i-1]))
if k%l[-1] == 0 and k <= m:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")
# Original solution
from bisect import bisect_left as bl
def main():
    N,K = list(map(int,input().split()))
    A = list(map(int,input().split()))
    A.sort()
    if K > max(A):
        print("IMPOSSIBLE")
        exit()
    if K in A:
        print("POSSIBLE")
        exit()
    M = max(A)
    E = list([abs(x-K) for x in A])
    E = set(E)
    C = [A[i+1]-A[i] for i in range(N-1)]
    C = set(C)
    D = set(A)
    if E&D:
        print("POSSIBLE")
        exit()
    for i in range(2,int(M**0.5)+10):
        B = set([x%i for x in A])
        if len(B) == 1:
            print("IMPOSSIBLE")
            exit()
    print("IMPOSIBLE")
    

if __name__ == "__main__":
    main()

# Optimized solution
def main():
    N,K = list(map(int,input().split()))
    A = list(map(int,input().split()))
    A.sort()
    if K > max(A):
        print("IMPOSSIBLE")
        exit()
    if K in A:
        print("POSSIBLE")
        exit()

    E = list([abs(x-K) for x in A])
    E = set(E)
    C = [A[i+1]-A[i] for i in range(N-1)]
    C = set(C)
    D = set(A)
    if E&D:
        print("POSSIBLE")
        exit()

    print("IMPOSSIBLE")
    

if __name__ == "__main__":
    main()
# Original solution
n, k = list(map(int, input().split()))
A = sorted(map(int, input().split()))
INF = 10**9+1
diff = INF
for x, y in zip(A, A[1:]):
    z = abs(x-y)
    if z > 0:
        diff = min(diff, z)

MAX = A[-1]
ans = False
for a in A:
    if a-k < 0:
        continue
    x, r = divmod((a-k), diff)
    if r == 0:
        ans = True
        break
print(("POSSIBLE" if ans else "IMPOSSIBLE"))


# Optimized solution
n, k = list(map(int, input().split()))
A = sorted(map(int, input().split()))

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


smallest_ball = A[0]
for a in A[1:]:
    smallest_ball = gcd(smallest_ball, a)

print(("POSSIBLE" if (A[-1]-k) %
      smallest_ball == 0 and k <= A[-1] else "IMPOSSIBLE"))
# Original solution
#! cat input | python3 main.py

n, k = list(map(int, input().split()))
a = list(map(int, input().split()))
if n == 1:
    if a[0] == k:
        print("POSSIBLE")
    else:
        print("IMPOSSIBLE")
    __import__("sys").exit()
a.sort()
ma = max(a)
def isfact(n):
    if n == 2: return True
    for i in (2, n**0.5 + 1):
        if n % i == 0:
            return False
    return True
def calcfacts():
    r = []
    for i in range(2, 10**5):
        if isfact(i):
            r.append(i)
    return r
allfacts = calcfacts()

def prim_fact(n):
    facts = []
    ti = 0
    t = allfacts[ti]
    nn = n ** 0.5 + 1
    while True:
        if n % t == 0:
            facts.append(t)
            n //= t
        else:
            ti += 1
            t = allfacts[ti]
        if t >= n or t > nn:
            if n != 1:
                facts.append(n)
            break
    return facts


def f(a, k, ma):
    minv = float("inf")
    for i, v in enumerate(a[1:]):
        if v - a[i] != 0:
            minv = min(minv, v - a[i])
    minv = min(minv, a[0])

    sets = []
    setn = set()
    for v in a:
        s = set(prim_fact(v))
        # sets.append(s)
        # for i in s: setn.add(i)
    # for v in setn:
    #     for s in sets:
    #         if v not in s:
    #             break
    #     else:
    #         minv = min(minv, v)
    #         break
    # else:
    #     return False

    if minv == 1:
        return False

    a = a[:]
    for i in range(0, ma + minv, minv):
        if i == k:
            return False
        if i < a[0]:
            continue
        if i == a[0]:
            del a[0]
        else:
            return False
    return True

if ma < k:
    print("IMPOSSIBLE")
elif f(a, k, ma):
    print("IMPOSSIBLE")
else:
    print("POSSIBLE")


# Optimized solution
a, b = list(map(int, input().split()))
array = list(map(int, input().split()))
impossible = "IMPOSSIBLE"
possible = "POSSIBLE"

array = list(set(array))

if len(array) == 1:
    if b == array[0]:
        print(possible)
    else:
        print(impossible)
    exit(0)

array.sort()

btw = [v1 - v2 for v1, v2 in zip(array[1:], array[0:])]
n = sorted(btw)[0]

same = len(set(btw)) == 1 or all([v % n == 0 for v in btw])

if b in array:
    print(possible)
elif array[-1] < b:
    print(impossible)
elif same and (b - array[0]) % n == 0:
    print(possible)
else:
    print(impossible)
# Original solution
N, K = list(map(int, input().split(" ")))

A = list(map(int, input().split(" ")))

ans = False

cnt = 0
prev_len = 0
prepre_len = 0

while(1):
    if K in A:
        ans = True
        break
        
    
     
    if cnt == 0:
        for i in range(len(A)-1):
            for j in range(i+1, len(A)):
                tmp = abs(A[i] - A[j])
#                 print(tmp)
                if tmp not in A:
                    A.append(tmp)
                    
    else :
        for i in range(len(A)-1):
            for j in range(prepre_len, len(A)):
                tmp = abs(A[i] - A[j])
#                 print(tmp)
                if tmp not in A:
                    A.append(tmp)
                    
    if len(A) == prev_len:
        ans = False
        break
                    
#     print(A)
    
    prepre_len = prev_len
    prev_len = len(A)
    cnt += 1
    
    
if ans == True:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")

# Optimized solution
N, K = list(map(int, input().split(" ")))

A = list(map(int, input().split(" ")))

ans = False

A = sorted(A)

key = 99999999999999
    
if A[-1] < K:
    ans = False

else:
    for i in range(2, A[0]+1):
        key_flag = True
        for a in A:
            if a % i !=0:
                key_flag = False
                break
                
        if key_flag == True:
            key = i
            break

    if key_flag == False:
        ans = True
#         print(1)
    elif K % key == 0:
        ans = True
#         print(2)
    else:
#         print(3)
        ans = False           
    
if ans == True:
    print("POSSIBLE")
else:
    print("IMPOSSIBLE")
# Original solution
import sys
from collections import Counter as ct

def factoring(n):
    root = int(n ** .5) + 1
    arr = []
    for i in range(2, root):
        while(n % i == 0):
            arr.append(i)
            n //= i
    if n > 1:
        arr.append(n)
    return ct(arr)

n, k = list(map(int, input().split()))
a = list(sorted(map(int, input().split())))

kp = factoring(k)
ap = list(map(factoring, a))
ap0 = ap[0]
for a_cnt in ap[1:]:
    ap0 = ap0 & a_cnt
prod = 1
for p, x in list(ap0.items()):
    prod *= p ** x

ans = 'POSSIBLE' if k % prod == 0 and k <= a[-1] else 'IMPOSSIBLE'
print(ans)


# Optimized solution
n, k = list(map(int, input().split()))
ar = list(sorted(map(int, input().split())))

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

l = ar[0]
for a in ar[1:]:
    l = lcm(l, a)

ans = 'POSSIBLE' if k % l == 0 and k <= ar[-1] else 'IMPOSSIBLE'
print(ans)
# Original solution
N,K = list(map(int,input().split()))
L = list(map(int,input().split()))
L = sorted(L,reverse=False)

ans = "IMPOSSIBLE"
if L[-1] < K :
    ans = "IMPOSSIBLE"
elif (K in L) or (1 in L) : 
    ans = "POSSIBLE"
else :
    for i in range(1,N) :
        if L[i] % L[0] != 0 :
            ans = "POSSIBLE"
            break

for i in range(N) :
    if (K + L[i]) in L :
        ans = "POSSIBLE"

print(ans)


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

N,K = list(map(int,input().split()))
L = list(map(int,input().split()))

if len(L) == 1 :
    if L[0] == K :
        ans = "POSSIBLE"
    else :
        ans = "IMPOSSIBLE"

else :
    for i in range(N-1) :
        q = gcd(L[i],L[i+1])
        if i == 0 :
            p = gcd(L[i],L[i+1])
        if q < p :
            p = q

    if (K % p ==  0) and (K <= max(L)) :
        ans = "POSSIBLE"
    else :
        ans = "IMPOSSIBLE"
print(ans)
# Original solution
def gcd_(a, b):
    if a < b:  a, b = b, a
    if b == 0:  return a
    return gcd_(b, a % b)

def gcd_bl(A):

    left = [0 for _ in range(N + 1)]
    right = [0 for _ in range(N + 1)]
    ans = [0 for _ in range(N)]

    left[1] = A[0]
    for i in range(1, N):  left[i + 1] = gcd_(left[i], A[i])
    right[-1 - 1] = A[-1]
    for i in range(1, N):  right[-1 - i - 1] = gcd_(right[-1 - i], A[-1 - i])
    for i in range(N):  ans[i] = gcd_(left[i], right[i + 1])
        
    return ans

def cin():
    in_ = list(map(int,input().split()))
    if len(in_) == 1:  return in_[0]
    else:  return in_

def solve():   
    if N == 1:  return A == K    
    g = gcd_bl(A)
    for i in range(N):
        if A[i] == K:  return 1
        elif A[i] > K:
            temp = (K - A[i]) / g[i]
            if temp == int(temp):  return 1
    return 0

N, K = cin()
A = cin()
ret = solve()
if ret:  print("POSSIBLE")
else:  print("IMPOSSIBLE")

# Optimized solution
def gcd_(a, b):
    if a < b:  a, b = b, a
    if b == 0:  return a
    return gcd_(b, a % b)

def gcd(l):
    ans = l[0]
    for i in l:  ans = gcd_(ans, i)
    return ans

def cin():
    in_ = list(map(int,input().split()))
    if len(in_) == 1:  return in_[0]
    else:  return in_

def solve():   
    if N == 1:  return A == K    
    g = gcd(A)
    m = max(A)
    return K <= m and K % g == 0

N, K = cin()
A = cin()
ret = solve()
if ret:  print("POSSIBLE")
else:  print("IMPOSSIBLE")