Problem:
Score : 700 points

Problem Statement

You are given four integers: H, W, h and w (1 ≤ h ≤ H, 1 ≤ w ≤ W).
Determine whether there exists a matrix such that all of the following conditions are held, and construct one such matrix if the answer is positive:

The matrix has H rows and W columns.

Each element of the matrix is an integer between -10^9 and 10^9 (inclusive).

The sum of all the elements of the matrix is positive.

The sum of all the elements within every subrectangle with h rows and w columns in the matrix is negative.

Constraints

1 ≤ h ≤ H ≤ 500

1 ≤ w ≤ W ≤ 500

Input

Input is given from Standard Input in the following format:

H W h w

Output

If there does not exist a matrix that satisfies all of the conditions, print No.

Otherwise, print Yes in the first line, and print a matrix in the subsequent lines in the following format:

a_{11} ... a_{1W}
:
a_{H1} ... a_{HW}

Here, a_{ij} represents the (i,\ j) element of the matrix.

Sample Input 1

3 3 2 2

Sample Output 1

Yes
1 1 1
1 -4 1
1 1 1

The sum of all the elements of this matrix is 4, which is positive.
Also, in this matrix, there are four subrectangles with 2 rows and 2 columns as shown below. For each of them, the sum of all the elements inside is -1, which is negative.

Sample Input 2

2 4 1 2

Sample Output 2

No

Sample Input 3

3 4 2 3

Sample Output 3

Yes
2 -5 8 7
3 -5 -4 -5
2 1 -1 7

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

#[allow(unused_imports)]
use std::cmp::*;
#[allow(unused_imports)]
use std::collections::*;

fn read<T: std::str::FromStr>() -> T {
    let mut s = String::new();
    std::io::stdin().read_line(&mut s).ok();
    s.trim().parse().ok().unwrap()
}

fn read_vec<T: std::str::FromStr>() -> Vec<T> {
    read::<String>()
        .split_whitespace()
        .map(|e| e.parse().ok().unwrap())
        .collect()
}

fn main() {
    let v = read_vec::<usize>();
    let (H, W, h, w) = (v[0], v[1], v[2], v[3]);
    if h == 1 || w == 1 {
        println!("No");
        return;
    }
    let positive_const = 10000000;
    let negative_const = -10000001;
    let mut grid = vec![vec![0; W]; H];

    let mut positive_placed = 0;
    let mut current_h = 0;
    let mut current_w = 0;
    while current_h < H {
        current_w = 0;
        while current_w < W {
            grid[current_h][current_w] = positive_const;
            current_w += w;
            positive_placed += 1;
        }
        current_h += h;
    }

    let mut negative_placed = 0;
    let mut current_h = h - 1;
    let mut current_w = w - 1;
    while current_h < H {
        current_w = w - 1;
        while current_w < W {
            grid[current_h][current_w] = negative_const;
            current_w += w;
            negative_placed += 1;
        }
        current_h += h;
    }

    if positive_placed > negative_placed {
        println!("Yes");
        for i in 0..H {
            println!(
                "{}",
                grid[i]
                    .iter()
                    .map(|x| x.to_string())
                    .collect::<Vec<_>>()
                    .join(" ")
            );
        }
    } else {
        println!("No");
    }
}