output_description: If it is possible for Snuke to reach the state where the box contains a ball
  on which the integer K is written, print `POSSIBLE`; if it is not possible,
  print `IMPOSSIBLE`.
  
  * * *
input_description: Input is given from Standard Input in the following format:
  
      
      
      N K
      A_1 A_2 ... A_N
attempt: import sys
  from sys import exit
  from collections import deque
  from bisect import bisect_left, bisect_right, insort_left, insort_right
  from heapq import heapify, heappop, heappush
  from itertools import product, permutations, combinations, combinations_with_replacement
  from functools import reduce
  from math import gcd, sin, cos, tan, asin, acos, atan, degrees, radians
  
  sys.setrecursionlimit(10**6)
  INF = 10**20
  eps = 1.0e-20
  MOD = 10**9 + 7
  
  
  def lcm(x, y):
      return x * y // gcd(x, y)
  
  
  def lgcd(l):
      return reduce(gcd, l)
  
  
  def llcm(l):
      return reduce(lcm, l)
  
  
  def powmod(n, i, mod):
      return pow(n, mod - 1 + i, mod) if i < 0 else pow(n, i, mod)
  
  
  def div2(x):
      return x.bit_length()
  
  
  def div10(x):
      return len(str(x)) - (x == 0)
  
  
  def perm(n, mod=None):
      ans = 1
      for i in range(1, n + 1):
          ans *= i
          if mod != None:
              ans %= mod
      return ans
  
  
  def intput():
      return int(input())
  
  
  def mint():
      return map(int, input().split())
  
  
  def lint():
      return list(map(int, input().split()))
  
  
  def ilint():
      return int(input()), list(map(int, input().split()))
  
  
  def judge(x, l=["Yes", "No"]):
      print(l[0] if x else l[1])
  
  
  def lprint(l, sep="\n"):
      for x in l:
          print(x, end=sep)
  
  
  def ston(c, c0="a"):
      return ord(c) - ord(c0)
  
  
  def ntos(x, c0="a"):
      return chr(x + ord(c0))
  
  
  class counter(dict):
      def __init__(self, *args):
          super().__init__(args)
  
      def add(self, x, d=1):
          self.setdefault(x, 0)
          self[x] += d
  
      def list(self):
          l = []
          for k in self:
              l.extend([k] * self[k])
          return l
  
  
  class comb:
      def __init__(self, n, mod=None):
          self.l = [1]
          self.n = n
          self.mod = mod
  
      def get(self, k):
          l, n, mod = self.l, self.n, self.mod
          k = n - k if k > n // 2 else k
          while len(l) <= k:
              i = len(l)
              l.append(
                  l[i - 1] * (n + 1 - i) // i
                  if mod == None
                  else (l[i - 1] * (n + 1 - i) * powmod(i, -1, mod)) % mod
              )
          return l[k]
  
  
  def pf(x):
      C = counter()
      p = 2
      while x > 1:
          k = 0
          while x % p == 0:
              x //= p
              k += 1
          if k > 0:
              C.add(p, k)
          p = p + 2 - (p == 2) if p * p < x else x
      return C
  
  
  N, K = mint()
  A = lint()
  judge(K <= max(A) and K % lgcd(A) == 0, ["POSSIBLE", "IMPOSSIBLE"])
  
problem_description: Statement
  
  There is a box containing N balls. The i-th ball has the integer A_i written
  on it. Snuke can perform the following operation any number of times:
  
    * Take out two balls from the box. Then, return them to the box along with a new ball, on which the absolute difference of the integers written on the two balls is written.
  
  Determine whether it is possible for Snuke to reach the state where the box
  contains a ball on which the integer K is written.
samples: [{"input": "3 7\n    9 3 4", "output": "POSSIBLE\n    \n\nFirst, take out the two balls 9 and 4, and return them back along with a new\nball, abs(9-4)=5. Next, take out 3 and 5, and return them back along with\nabs(3-5)=2. Finally, take out 9 and 2, and return them back along with\nabs(9-2)=7. Now we have 7 in the box, and the answer is therefore `POSSIBLE`.\n\n* * *"}, {"input": "3 5\n    6 9 3", "output": "IMPOSSIBLE\n    \n\nNo matter what we do, it is not possible to have 5 in the box. The answer is\ntherefore `IMPOSSIBLE`.\n\n* * *"}, {"input": "4 11\n    11 3 7 15", "output": "POSSIBLE\n    \n\nThe box already contains 11 before we do anything. The answer is therefore\n`POSSIBLE`.\n\n* * *"}, {"input": "5 12\n    10 2 8 6 4", "output": "IMPOSSIBLE"}]