Problem:
Score : 700 points

Problem 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.

Constraints

2 ≦ N ≦ 100

1 ≦ a_i ≦ N-1

Input

The input is given from Standard Input in the following format:

N
a_1 a_2 ... a_N

Output

If there exists a tree that satisfies the condition, print Possible. Otherwise, print Impossible.

Sample Input 1

5
3 2 2 3 3

Sample Output 1

Possible

The diagram above shows an example of a tree that satisfies the conditions. The red arrows show paths from each vertex to the farthest vertex from it.

Sample Input 2

3
1 1 2

Sample Output 2

Impossible

Sample Input 3

10
1 2 2 2 2 2 2 2 2 2

Sample Output 3

Possible

Sample Input 4

10
1 1 2 2 2 2 2 2 2 2

Sample Output 4

Impossible

Sample Input 5

6
1 1 1 1 1 5

Sample Output 5

Impossible

Sample Input 6

5
4 3 2 3 4

Sample Output 6

Possible

Solution in Rust (1.15.1) (judge verdict: Runtime Error)

use std::io;
use std::collections::VecDeque;

fn main() {
    println!("{}", solve());
}

fn solve() -> String {
    let mut input = Input::new();
    let n: usize = input.next();
    let mut a: Vec<usize> = (0..n).map(|_| input.next()).collect();
    a.sort();
    if a[0] == a[2] {
        return String::from("Impossible");
    }
    let m = a[0];
    let x = m - if m < a[1] { 0 } else { 1 };
    let mut c = vec![0; n];
    for v in a {
        c[v] += 1;
    }
    for i in 0..n {
        if i == m {
            continue;
        }
        if (i < m || m + x < i) && c[i] > 0 {
            return String::from("Impossible");
        }
        if !(i < m || m + x < i) && c[i] < 2 {
            return String::from("Impossible");
        }
    }
    String::from("Possible")
}

struct Input {
    queue: VecDeque<String>,
}

impl Input {
    fn new() -> Input {
        Input { queue: VecDeque::new() }
    }

    fn next<T>(&mut self) -> T
        where T: std::str::FromStr,
              T::Err: std::fmt::Debug
    {
        if self.queue.is_empty() {
            let mut line = String::new();
            let _ = io::stdin().read_line(&mut line);
            for x in line.split_whitespace() {
                self.queue.push_back(String::from(x));
            }
        }
        return self.queue.pop_front().unwrap().parse::<T>().unwrap();
    }
}