Problem:
Score : 300 points

Problem Statement

We have a square grid with H rows and W columns.
Snuke wants to write 0 or 1 in each of the squares.
Here, all of the following conditions have to be satisfied:

For every row, the smaller of the following is A: the number of 0s contained in the row, and the number of 1s contained in the row. (If these two numbers are equal, “the smaller” should be read as “either”.)

For every column, the smaller of the following is B: the number of 0s contained in the column, and the number of 1s contained in the column.

Determine if these conditions can be satisfied by writing 0 or 1 in each of the squares. If the answer is yes, show one way to fill the squares so that the conditions are satisfied.

Constraints

1 \leq H,W \leq 1000

0 \leq A

2 \times A \leq W

0 \leq B

2 \times B \leq H

All values in input are integers.

Input

Input is given from Standard Input in the following format:

H W A B

Output

If the conditions cannot be satisfied by writing 0 or 1 in each of the squares, print -1.

If the conditions can be satisfied, print one way to fill the squares so that the conditions are satisfied, in the following format:

s_{11}s_{12}\cdots s_{1W}
s_{21}s_{22}\cdots s_{2W}
\vdots
s_{H1}s_{H2}\cdots s_{HW}

Here s_{ij} is the digit written in the square at the i-th row from the top and the j-th column from the left in the grid.

If multiple solutions exist, printing any of them will be accepted.

Sample Input 1

3 3 1 1

Sample Output 1

100
010
001

Every row contains two 0s and one 1, so the first condition is satisfied.
Also, every column contains two 0s and one 1, so the second condition is satisfied.

Sample Input 2

1 5 2 0

Sample Output 2

01010

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

//  ____            _                  _                       _       _
// |  _ \ _   _ ___| |_    ___ _ __   | |_ ___ _ __ ___  _ __ | | __ _| |_ ___
// | |_) | | | / __| __|  / __| '_ \  | __/ _ \ '_ ` _ \| '_ \| |/ _` | __/ _ \
// |  _ <| |_| \__ \ |_  | (__| |_) | | ||  __/ | | | | | |_) | | (_| | ||  __/
// |_| \_\\__,_|___/\__|  \___| .__/___\__\___|_| |_| |_| .__/|_|\__,_|\__\___|
//                            |_| |_____|               |_|

//                                                     _        _ _ _____  ___
//                               _ __ ___   __ _ _ __ | |_ __ _/ / |___ / / _ \
//                              | '_ ` _ \ / _` | '_ \| __/ _` | | | |_ \| | | |
//                              | | | | | | (_| | | | | || (_| | | |___) | |_| |
//                              |_| |_| |_|\__,_|_| |_|\__\__,_|_|_|____/ \___/

//https://github.com/manta1130/Competitive_Programming_Template_Rust

#[macro_use]
mod input {

    use std;
    use std::io;

    const SPLIT_DELIMITER: char = ' ';

    #[macro_export]
    #[allow(unused_macros)]
    macro_rules! input {
    ( $($x:expr ),*) => {
        {
            let temp_str = input_line_str();
            let mut split_result_iter = temp_str.split_whitespace();
                $(
                let buf_split_result = split_result_iter.next();
                let buf_split_result = buf_split_result.unwrap();
                    ($x) = buf_split_result.parse().unwrap();
                )*
        }
    };
}

    #[allow(dead_code)]
    pub fn input_line_str() -> String {
        let mut s = String::new();
        io::stdin().read_line(&mut s).unwrap();
        s.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn p<T>(t: T)
    where
        T: std::fmt::Display,
    {
        println!("{}", t);
    }

    #[allow(dead_code)]
    pub fn input_vector2d<T>(line: usize) -> Vec<Vec<T>>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<Vec<T>> = Vec::new();

        for _ in 0..line {
            let vec_line = input_vector();
            v.push(vec_line);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector<T>() -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v: Vec<T> = Vec::new();

        let s = input_line_str();
        let split_result = s.split(SPLIT_DELIMITER);
        for z in split_result {
            let buf = match z.parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    #[allow(dead_code)]
    pub fn input_vector_row<T>(n: usize) -> Vec<T>
    where
        T: std::str::FromStr,
    {
        let mut v = Vec::with_capacity(n);
        for _ in 0..n {
            let buf = match input_line_str().parse() {
                Ok(r) => r,
                Err(_) => panic!("Parse Error"),
            };
            v.push(buf);
        }
        v
    }

    pub trait ToCharVec {
        fn to_charvec(&self) -> Vec<char>;
    }

    impl ToCharVec for String {
        fn to_charvec(&self) -> Vec<char> {
            self.to_string().chars().collect::<Vec<_>>()
        }
    }
}

use input::*;
use std::collections::VecDeque;

fn main() {
    let (mut h, mut w, mut a, mut b): (usize, usize, usize, usize);
    input!(h, w, a, b);

    if b == 0 && h == 1 {
        if 2 * a > w {
            p("No");
            return;
        }
        for z in 0..a {
            print!("0");
        }
        for z in a..w {
            print!("1");
        }
        println!("");
        return;
    }
    if a == 0 && w == 1 {
        if 2 * b > h {
            p("No");
            return;
        }
        for z in 0..b {
            println!("0");
        }
        for z in b..h {
            println!("1");
        }
        return;
    }

    let mut dq = VecDeque::new();
    for z in 0..w {
        if z < a {
            dq.push_back(0);
        } else {
            dq.push_back(1);
        }
    }

    if h % w == 0 && b % a == 0 && h / w == b / a {
        let buf1 = w;
        w = h;
        h = buf1;
        let buf2 = a;
        a = b;
        b = buf2;

        let mut dq2 = VecDeque::new();
        for z in 0..w {
            if z < a {
                dq2.push_back(0);
            } else {
                dq2.push_back(1);
            }
        }

        let mut v = vec![vec![0; w]; h];

        for c1 in 0..h {
            let mut c2 = 0;
            for j in dq2.iter() {
                v[c1][c2] = *j;
                c2 += 1;
            }
            for _ in 0..a {
                let buf = dq2.pop_front().unwrap();
                dq2.push_back(buf);
            }
        }

        for l in 0..w {
            for k in 0..h {
                print!("{}", v[k][l]);
            }
            println!("");
        }
        return;
    }

    if w % h == 0 && a % b == 0 && w / h == a / b {
        for _ in 0..h {
            for j in dq.iter() {
                print!("{}", *j);
            }
            println!("");
            for _ in 0..a {
                let buf = dq.pop_front().unwrap();
                dq.push_back(buf);
            }
        }
        return;
    }

    if h != w || a != b || 2 * b > h || 2 * a > w {
        p("No");
        return;
    }

    let mut dq = VecDeque::new();
    for z in 0..h {
        if z < a {
            dq.push_back(0);
        } else {
            dq.push_back(1);
        }
    }

    for _ in 0..h {
        for j in dq.iter() {
            print!("{}", *j);
        }
        println!("");
        let buf = dq.pop_front().unwrap();
        dq.push_back(buf);
    }
}