Problem:
Score : 900 points

Problem Statement

AtCoDeer the deer wants a directed graph that satisfies the following conditions:

The number of vertices, N, is at most 300.

There must not be self-loops or multiple edges.

The vertices are numbered from 1 through N.

Each edge has either an integer weight between 0 and 100 (inclusive), or a label X or Y.

For every pair of two integers (x,y) such that 1 ≤ x ≤ A, 1 ≤ y ≤ B,
the shortest distance from Vertex S to Vertex T in the graph where the edges labeled X have the weight x and the edges labeled Y have the weight y, is d_{x,y}.

Construct such a graph (and a pair of S and T) for him, or report that it does not exist.
Refer to Output section for output format.

Constraints

1 ≤ A,B ≤ 10

1 ≤ d_{x,y} ≤ 100 (1 ≤ x ≤ A, 1 ≤ y ≤ B)

All input values are integers.

Input

Input is given from Standard Input in the following format:

A B
d_{1,1} d_{1,2} .. d_{1,B}
d_{2,1} d_{2,2} .. d_{2,B}
:
d_{A,1} d_{A,2} .. d_{A,B}

Output

If no graph satisfies the condition, print Impossible.

If there exists a graph that satisfies the condition, print Possible in the first line.
Then, in the subsequent lines, print the constructed graph in the following format:

N M
u_1 v_1 c_1
u_2 v_2 c_2
:
u_M v_M c_M
S T

Here, M is the number of the edges, and u_i, v_i, c_i represent edges as follows: there is an edge from Vertex u_i to Vertex v_i whose weight or label is c_i.

Also refer to Sample Outputs.

Sample Input 1

2 3
1 2 2
1 2 3

Sample Output 1

Possible
3 4
1 2 X
2 3 1
3 2 Y
1 3 Y
1 3

Sample Input 2

1 3
100 50 1

Sample Output 2

Impossible

Solution in Rust (1.42.0) (judge verdict: Accepted)

use itertools::iproduct;
use proconio::input;

#[derive(Debug, Clone, Copy)]
enum Label {
    X,
    Y,
    Integer(usize),
}

fn err() -> ! {
    println!("Impossible");
    std::process::exit(0);
}

fn main() {
    input!(a: usize, b: usize, d: [[usize; b]; a]);
    let mut coeff = vec![vec![None; b]; a];
    for (i, j) in iproduct!(0..a, 0..b) {
        'coeff: for (k, l) in iproduct!(0..=100, 0..=100) {
            let base = |x, y| (x + 1) * k + (y + 1) * l;
            if d[i][j] < base(i, j) {
                continue;
            }
            let r = d[i][j] - base(i, j);
            for (i1, j1) in iproduct!(0..a, 0..b) {
                if base(i1, j1) + r < d[i1][j1] {
                    continue 'coeff;
                }
            }
            coeff[i][j] = Some((k, l, r));
            break;
        }
    }
    let coeff: Vec<Vec<(usize, usize, usize)>> = coeff
        .iter()
        .map(|v| v.iter().map(|x| x.unwrap_or_else(|| err())).collect())
        .collect();

    let cliff_size = coeff
        .iter()
        .map(|v| v.iter().map(|x| x.0.max(x.1) + 1))
        .flatten()
        .max()
        .unwrap();
    let vertex_count = cliff_size * 2;

    let mut edges = vec![];
    for i in 0..cliff_size - 1 {
        edges.push((i, i + 1, Label::X));
        edges.push((cliff_size + i, cliff_size + i + 1, Label::Y));
    }
    let mut ckd = vec![vec![false; cliff_size]; cliff_size];
    for (i, j) in iproduct!(0..a, 0..b) {
        let (k, l, r) = coeff[i][j];
        if ckd[k][l] {
            continue;
        }
        ckd[k][l] = true;
        edges.push((k, 2 * cliff_size - 1 - l, Label::Integer(r)));
    }
    let edge_count = edges.len();

    assert!(vertex_count <= 300);
    if 300 < vertex_count {
        err();
    }

    println!("Possible");
    println!("{} {}", vertex_count, edge_count);
    for (u, v, w) in edges {
        println!(
            "{} {} {}",
            u + 1,
            v + 1,
            match w {
                Label::X => 'X'.to_string(),
                Label::Y => 'Y'.to_string(),
                Label::Integer(x) => x.to_string(),
            }
        );
    }
    println!("{} {}", 1, vertex_count);
}