Problem:
Score : 1400 points

Problem Statement

Given are a positive integer N and a sequence of length 2^N consisting of 0s and 1s: A_0,A_1,\ldots,A_{2^N-1}.
Determine whether there exists a closed curve C that satisfies the condition below for all 2^N sets S \subseteq \{0,1,\ldots,N-1 \}. If the answer is yes, construct one such closed curve.

Let x = \sum_{i \in S} 2^i and B_S be the set of points \{ (i+0.5,0.5) | i \in S \}.

If there is a way to continuously move the closed curve C without touching B_S so that every point on the closed curve has a negative y-coordinate, A_x = 1.

If there is no such way, A_x = 0.

For instruction on printing a closed curve, see Output below.

Notes

C is said to be a closed curve if and only if:

C is a continuous function from [0,1] to \mathbb{R}^2 such that C(0) = C(1).

We say that a closed curve C can be continuously moved without touching a set of points X so that it becomes a closed curve D if and only if:

There exists a function f : [0,1] \times [0,1] \rightarrow \mathbb{R}^2 that satisfies all of the following.

f is continuous.

f(0,t) = C(t).

f(1,t) = D(t).

f(x,t) \notin X.

Constraints

1 \leq N \leq 8

A_i = 0,1 \quad (0 \leq i \leq 2^N-1)

A_0 = 1

Input

Input is given from Standard Input in the following format:

N
A_0A_1 \cdots A_{2^N-1}

Output

If there is no closed curve that satisfies the condition, print Impossible.

If such a closed curve exists, print Possible in the first line.
Then, print one such curve in the following format:

L
x_0 y_0
x_1 y_1
:
x_L y_L

This represents the closed polyline that passes (x_0,y_0),(x_1,y_1),\ldots,(x_L,y_L) in this order.

Here, all of the following must be satisfied:

0 \leq x_i \leq N, 0 \leq y_i \leq 1, and x_i, y_i are integers. (0 \leq i \leq L)

|x_i-x_{i+1}| + |y_i-y_{i+1}| = 1. (0 \leq i \leq L-1)

(x_0,y_0) = (x_L,y_L).

Additionally, the length of the closed curve L must satisfy 0 \leq L \leq 250000.

It can be proved that, if there is a closed curve that satisfies the condition in Problem Statement, there is also a closed curve that can be expressed in this format.

Sample Input 1

1
10

Sample Output 1

Possible
4
0 0
0 1
1 1
1 0
0 0

When S = \emptyset, we can move this curve so that every point on it has a negative y-coordinate.

When S = \{0\}, we cannot do so.

Sample Input 2

2
1000

Sample Output 2

Possible
6
1 0
2 0
2 1
1 1
0 1
0 0
1 0

The output represents the following curve:

Sample Input 3

2
1001

Sample Output 3

Impossible

Sample Input 4

1
11

Sample Output 4

Possible
0
1 1

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

macro_rules ! input { ( source = $ s : expr , $ ( $ r : tt ) * ) => { let mut iter = $ s . split_whitespace ( ) ; input_inner ! { iter , $ ( $ r ) * } } ; ( iter = $ iter : ident , $ ( $ r : tt ) * ) => { let s = { use std :: io :: Read ; let mut s = String :: new ( ) ; std :: io :: stdin ( ) . read_to_string ( & mut s ) . unwrap ( ) ; s } ; let mut $ iter = s . split_whitespace ( ) ; input_inner ! { $ iter , $ ( $ r ) * } } ; ( $ ( $ r : tt ) * ) => { let s = { use std :: io :: Read ; let mut s = String :: new ( ) ; std :: io :: stdin ( ) . read_to_string ( & mut s ) . unwrap ( ) ; s } ; let mut iter = s . split_whitespace ( ) ; input_inner ! { iter , $ ( $ r ) * } } ; }
macro_rules ! input_inner { ( $ iter : expr ) => { } ; ( $ iter : expr , ) => { } ; ( $ iter : expr , mut $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let mut $ var = read_value ! ( $ iter , $ t ) ; input_inner ! { $ iter $ ( $ r ) * } } ; ( $ iter : expr , mut $ var : ident $ ( $ r : tt ) * ) => { input_inner ! { $ iter , mut $ var : usize $ ( $ r ) * } } ; ( $ iter : expr , $ var : ident : $ t : tt $ ( $ r : tt ) * ) => { let $ var = read_value ! ( $ iter , $ t ) ; input_inner ! { $ iter $ ( $ r ) * } } ; ( $ iter : expr , $ var : ident $ ( $ r : tt ) * ) => { input_inner ! { $ iter , $ var : usize $ ( $ r ) * } } ; }
macro_rules ! read_value { ( $ iter : expr , ( $ ( $ t : tt ) ,* ) ) => { ( $ ( read_value ! ( $ iter , $ t ) ) ,* ) } ; ( $ iter : expr , [ $ t : tt ; $ len : expr ] ) => { ( 0 ..$ len ) . map ( | _ | read_value ! ( $ iter , $ t ) ) . collect ::< Vec < _ >> ( ) } ; ( $ iter : expr , { chars : $ base : expr } ) => { read_value ! ( $ iter , String ) . chars ( ) . map ( | c | ( c as u8 - $ base as u8 ) as usize ) . collect ::< Vec < usize >> ( ) } ; ( $ iter : expr , { char : $ base : expr } ) => { read_value ! ( $ iter , { chars : $ base } ) [ 0 ] } ; ( $ iter : expr , chars ) => { read_value ! ( $ iter , String ) . chars ( ) . collect ::< Vec < char >> ( ) } ; ( $ iter : expr , char ) => { read_value ! ( $ iter , chars ) [ 0 ] } ; ( $ iter : expr , usize1 ) => { read_value ! ( $ iter , usize ) - 1 } ; ( $ iter : expr , $ t : ty ) => { $ iter . next ( ) . unwrap ( ) . parse ::<$ t > ( ) . unwrap ( ) } ; }
#[derive(Clone, Copy, Debug)]
pub enum Go {
    L,
    R,
    D,
    U,
    T,
}
impl Go {
    pub fn rev(self) -> Self {
        match self {
            Go::L => Go::R,
            Go::R => Go::L,
            g => g,
        }
    }
}
fn rec(i: usize) -> Vec<Go> {
    if i == 0 {
        vec![]
    } else if i == 1 {
        vec![Go::R, Go::U, Go::L, Go::D]
    } else if i & 1 == 1 {
        let mut res = vec![Go::R];
        let v = rec(i / 2);
        res.extend(v.clone());
        res.push(Go::L);
        res.push(Go::U);
        res.push(Go::R);
        res.extend(v.into_iter().rev().map(|g| g.rev()));
        res.push(Go::L);
        res.push(Go::D);
        res
    } else {
        let mut res = vec![Go::T, Go::R, Go::T];
        res.extend(rec(i / 2));
        res.push(Go::T);
        res.push(Go::L);
        res.push(Go::T);
        res
    }
}
fn main() {
    input! { n, a: { chars: '0' } };
    if (0..1 << n).all(|i| a[i] == 0 || (0..1 << n).all(|j| i & j != j || a[j] == 1)) {
        println!("Possible");
        let mut used = vec![false; 1 << n];
        let mut v = vec![];
        for i in 0..1 << n {
            if a[i] == 0 && !used[i] {
                v.push(i);
                for j in 0..1 << n {
                    if i & j == i {
                        used[j] = true;
                    }
                }
            }
        }
        let mut path = vec![];
        for i in v.into_iter() {
            path.extend(rec(i));
        }
        let (mut x, mut y) = (0, 0);
        let mut t = false;
        let mut ans = vec![(x, y)];
        for g in path.into_iter() {
            match g {
                Go::L => {
                    x -= 1;
                }
                Go::R => {
                    x += 1;
                }
                Go::U => {
                    y += 1;
                }
                Go::D => {
                    y -= 1;
                }
                Go::T => {
                    if y == 1 {
                        if !t {
                            y = 0;
                            t = true;
                        } else {
                            continue;
                        }
                    } else if y == 0 {
                        if t {
                            y = 1;
                            t = false;
                        } else {
                            continue;
                        }
                    }
                }
            }
            ans.push((x, y));
        }
        println!("{}", ans.len() - 1);
        for (x, y) in ans.into_iter() {
            println!("{} {}", x, y);
        }
    } else {
        println!("Impossible");
    }
}