output_description: If there exists a tree that satisfies the condition, print `Possible`.
  Otherwise, print `Impossible`.
  
  * * *
input_description: The input is given from Standard Input in the following format:
  
      
      
      N
      a_1 a_2 ... a_N
attempt: import math
  import fractions
  
  # import sys
  # input = sys.stdin.readline
  
  
  def make_divisors(n):
      divisors = []
      for i in range(1, int(n**0.5) + 1):
          if n % i == 0:
              divisors.append(i)
              if i != n // i:
                  divisors.append(n // i)
  
      # divisors.sort()
      return divisors
  
  
  def ValueToBits(x, digit):
      res = [0 for i in range(digit)]
      now = x
      for i in range(digit):
          res[i] = now % 2
          now = now >> 1
      return res
  
  
  def BitsToValue(arr):
      n = len(arr)
      ans = 0
      for i in range(n):
          ans += arr[i] * 2**i
      return ans
  
  
  def ZipArray(a):
      aa = [[a[i], i] for i in range(n)]
  
      aa.sort(key=lambda x: x[0])
      for i in range(n):
          aa[i][0] = i + 1
      aa.sort(key=lambda x: x[1])
      b = [aa[i][0] for i in range(len(a))]
      return b
  
  
  def ValueToArray10(x, digit):
      ans = [0 for i in range(digit)]
      now = x
      for i in range(digit):
          ans[digit - i - 1] = now % 10
          now = now // 10
      return ans
  
  
  def Zeros(a, b):
      if b <= -1:
          return [0 for i in range(a)]
      else:
          return [[0 for i in range(b)] for i in range(a)]
  
  
  class Bit:
      def __init__(self, n):
          self.size = n
          self.tree = [0] * (n + 1)
  
      def sum(self, i):
          s = 0
          while i > 0:
              s += self.tree[i]
              i -= i & -i
          return s
  
      def add(self, i, x):
          while i <= self.size:
              self.tree[i] += x
              i += i & -i
  
  
  """
  def cmb(n, r, p):
      if (r < 0) or (n < r):
          return 0
      r = min(r, n - r)
      return fact[n] * factinv[r] * factinv[n-r] % p
  
  p = 2
  N = 10 ** 6 + 2
  fact = [1, 1]  # fact[n] = (n! mod p)
  factinv = [1, 1]  # factinv[n] = ((n!)^(-1) mod p)
  inv = [0, 1]  # factinv 計算用
  
  for i in range(2, N + 1):
      fact.append((fact[-1] * i) % p)
      inv.append((-inv[p % i] * (p // i)) % p)
      factinv.append((factinv[-1] * inv[-1]) % p)
  
  """
  
  # a = list(map(int, input().split()))
  
  #################################################
  #################################################
  #################################################
  #################################################
  
  
  n = int(input())
  a = list(map(int, input().split()))
  
  num = Zeros(n, -1)
  
  for i in range(n):
      num[a[i]] += 1
  
  mx = max(a)
  
  # print(num)
  ans = "Possible"
  if mx % 2 == 0:
      num[mx // 2] -= 1
      if num[mx // 2] < 0:
          ans = "Impossible"
  
  now = mx // 2 + 1
  
  
  for i in range(mx - now + 1):
      num[now + i] -= 2
      if num[now + i] < 0:
          ans = "Impossible"
  # print(num)
  
  if sum(num[0:now]) >= 1:
      ans = "Impossible"
  
  print(ans)
  
problem_description: Statement
  
  Aoki loves numerical sequences and trees.
  
  One day, Takahashi gave him an integer sequence of length N, a_1, a_2, ...,
  a_N, which made him want to construct a tree.
  
  Aoki wants to construct a tree with N vertices numbered 1 through N, such that
  for each i = 1,2,...,N, the distance between vertex i and the farthest vertex
  from it is a_i, assuming that the length of each edge is 1.
  
  Determine whether such a tree exists.
samples: [{"input": "5\n    3 2 2 3 3", "output": "Possible\n    \n\n![](https://atcoder.jp/img/agc005/cda0380bb5cd1b9502cfceaf2526d91e.png)\n\nThe diagram above shows an example of a tree that satisfies the conditions.\nThe red arrows show paths from each vertex to the farthest vertex from it.\n\n* * *"}, {"input": "3\n    1 1 2", "output": "Impossible\n    \n\n* * *"}, {"input": "10\n    1 2 2 2 2 2 2 2 2 2", "output": "Possible\n    \n\n* * *"}, {"input": "10\n    1 1 2 2 2 2 2 2 2 2", "output": "Impossible\n    \n\n* * *"}, {"input": "6\n    1 1 1 1 1 5", "output": "Impossible\n    \n\n* * *"}, {"input": "5\n    4 3 2 3 4", "output": "Possible"}]