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: Accepted)

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

fn main() {
    if true {
        let mut input = Input::new();
        let H: usize = input.next();
        let W: usize = input.next();
        let h: usize = input.next();
        let w: usize = input.next();
        let (ok, b) = solve(H, W, h, w);
        if ok {
            println!("Yes");
            for i in 0..H {
                for j in 0..W {
                    print!(" {}", b[i][j]);
                }
                println!("");
            }
        } else {
            println!("No");
        }
    } else {
        for H in 1..10 {
            for W in 1..10 {
                for h in 1..H {
                    for w in 1..W {
                        let (ok, _) = solve(H, W, h, w);
                        println!("{} {} {} {} {}", H, W, h, w, ok);
                    }
                }
            }
        }
    }
}

fn solve(H: usize, W: usize, h: usize, w: usize) -> (bool, Vec<Vec<i32>>) {
    let mut b = vec![vec![1000 as i32; W]; H];
    for i in 1..H / h + 1 {
        for j in 1..W / w + 1 {
            b[i * h - 1][j * w - 1] = (h as i32 * w as i32 - 1) * -1000 - 1;
        }
    }
    let mut sum = 0;
    for i in 0..H {
        for j in 0..W {
            sum += b[i][j];
        }
    }
    return (sum >= 0, b);
}

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();
    }
}