import collections
import unittest


def solve(n, a):
    POSSIBLE = 'Possible'
    IMPOSSIBLE = 'Impossible'

    a.sort()
    counter = collections.Counter(a)
    max_k = max(counter)
    min_k = (max_k+1)//2
    if min(counter) < min_k or min_k not in counter:
        return IMPOSSIBLE
    if counter[max_k] < 2:
        return IMPOSSIBLE
    if max_k == 1 and n > 2:
        return IMPOSSIBLE
    if max_k % 2 == 0:
        if counter[min_k] != 1:
            return IMPOSSIBLE
        if any([i not in counter or counter[i] < 2 for i in range(min_k + 1, max_k+1)]):
            return IMPOSSIBLE
    else:
        if counter[min_k] != 2:
            return IMPOSSIBLE
        if any([i not in counter or counter[i] < 2 for i in range(min_k, max_k+1)]):
            return IMPOSSIBLE
    return POSSIBLE


def main():
    n = int(input())
    a = list(map(int, input().split()))
    result = solve(n, a)
    print(result)


if __name__ == "__main__":
    main()


class Test(unittest.TestCase):
    def test1(self):
        n = 5
        a = [3, 2, 2, 3, 3]
        expected = 'Possible'
        self.assertEqual(solve(n, a), expected)

    def test2(self):
        n = 3
        a = [1, 1, 2]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test3(self):
        n = 10
        a = [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, ]
        expected = 'Possible'
        self.assertEqual(solve(n, a), expected)

    def test4(self):
        n = 10
        a = [1, 1, 2, 2, 2, 2, 2, 2, 2, 2, ]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test5(self):
        n = 6
        a = [1, 1, 1, 1, 1, 5]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test6(self):
        n = 5
        a = [4, 3, 2, 3, 4]
        expected = 'Possible'
        self.assertEqual(solve(n, a), expected)

    def test_hand1(self):
        n = 5
        a = [4, 4, 2, 4, 4]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test_hand2(self):
        n = 2
        a = [1, 1]
        expected = 'Possible'
        self.assertEqual(solve(n, a), expected)

    def test_hand3(self):
        n = 2
        a = [2, 2]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test_hand4(self):
        n = 3
        a = [1, 1, 1]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test_hand5(self):
        n = 3
        a = [2, 2, 2]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test_hand6(self):
        n = 95
        a = [22, 23, 25, 20, 22, 16, 21, 22, 14, 25, 14, 16, 20, 21, 17, 18, 21, 14, 23, 23, 15, 19, 15, 17, 22, 24, 22, 23, 15, 25, 13, 21, 24, 15, 23, 15, 15, 24, 21, 15, 25, 16, 21, 16, 25, 19, 21,
             15, 18, 21, 19, 13, 17, 20, 16, 19, 15, 23, 24, 21, 20, 25, 25, 16, 22, 21, 14, 24, 16, 16, 16, 17, 14, 24, 18, 13, 22, 20, 25, 17, 14, 14, 20, 14, 14, 15, 14, 14, 23, 18, 24, 14, 14, 25, 25]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)

    def test_hand7(self):
        n = 6
        a = [2, 2, 2, 3, 3, 3]
        expected = 'Impossible'
        self.assertEqual(solve(n, a), expected)


Measured memory_bytes: 16240