Problem:
Score : 600 points

Problem Statement

We have a grid with A horizontal rows and B vertical columns, with the squares painted white. On this grid, we will repeatedly apply the following operation:

Assume that the grid currently has a horizontal rows and b vertical columns. Choose "vertical" or "horizontal".

If we choose "vertical", insert one row at the top of the grid, resulting in an (a+1) \times b grid.

If we choose "horizontal", insert one column at the right end of the grid, resulting in an a \times (b+1) grid.

Then, paint one of the added squares black, and the other squares white.

Assume the grid eventually has C horizontal rows and D vertical columns. Find the number of ways in which the squares can be painted in the end, modulo 998244353.

Constraints

1 \leq A \leq C \leq 3000

1 \leq B \leq D \leq 3000

A, B, C, and D are integers.

Input

Input is given from Standard Input in the following format:

A B C D

Output

Print the number of ways in which the squares can be painted in the end, modulo 998244353.

Sample Input 1

1 1 2 2

Sample Output 1

3

Any two of the three squares other than the bottom-left square can be painted black.

Sample Input 2

2 1 3 4

Sample Output 2

65

Sample Input 3

31 41 59 265

Sample Output 3

387222020

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

#![allow(
    non_snake_case,
    unused_variables,
    unused_assignments,
    unused_mut,
    dead_code
)]
use proconio::input;
//use proconio::marker::Usize1;
//use proconio::marker::Chars;
//use std::collections::HashSet;
//use std::cmp::*;

fn main() {
    input! {
        a: usize,
        b: usize,
        c: usize,
        d: usize
    }
    let m = 998244353u64;
    let mut dp: Vec<Vec<u64>> = vec![vec![0; d + 1]; c + 1];
    // dp[i][j][0]=i行j列で、最後(i-1)の行目に黒が1つだけ。つまり最後の操作は行の追加。
    // dp[i][j][1] 最後の操作は列(j-1)の追加。
    // 初期値として、
    dp[a][b] = 1;
    //println!("{:?}", dp);
    for i in a..c + 1 {
        for j in b..d + 1 {
            if i == a && j == b {
                continue;
            };
            dp[i][j] = m + dp[i - 1][j] * (j as u64) + dp[i][j - 1] * (i as u64);
            dp[i][j] -= dp[i - 1][j - 1] * (i as u64 - 1) * (j as u64 - 1) % m;
            dp[i][j] = dp[i][j] % m;
        }
    }
    //println!("{:?}", dp);

    println!("{}", dp[c][d] % m);
}
//ij=5,6,7
//[[[0, 0], [0, 1], [0, 1], [0, 1], [0, 1]],
// [[0, 0], [----], [0, 0], [0, 0], [0, 1]],
// [[0, 0], [----], [0, 2], [0, 4], [4, 8]],
// [[0, 1], [1, 0], [4, 1], [12, 7], [48, 33]]]