use std::cmp::Ordering; use std::cmp; use std::cmp::min; use std::collections::BTreeMap; use std::process; use std::cmp::Ord; use std::collections::HashMap; use std::collections::HashSet; use std::collections::VecDeque; use std::collections::BTreeSet; use std::mem; use std::collections::BinaryHeap; use std::hash::{Hash, Hasher}; pub struct Scanner { stdin: R, } impl Scanner { pub fn read(&mut self) -> T { use std::io::Read; let buf = self .stdin .by_ref() .bytes() .map(|b| b.unwrap()) .skip_while(|&b| b == b' ' || b == b'\n' || b == b'\r') .take_while(|&b| b != b' ' && b != b'\n' && b != b'\r') .collect::>(); std::str::from_utf8(&buf).unwrap() .parse() .ok() .expect("Parse error.") } pub fn vec(&mut self, n: usize) -> Vec { (0..n).map(|_| self.read()).collect() } pub fn chars(&mut self) -> Vec { self.read::().chars().collect() } } pub trait BinarySearch { fn lower_bound(&self, x:&T) -> usize; fn upper_bound(&self, x:&T) -> usize; } impl BinarySearch for VecDeque{ fn lower_bound(&self, x: &T) -> usize { let mut low = 0; let mut high = self.len(); while low != high { let mid = (low + high) / 2; match self[mid].cmp(x) { Ordering::Less => { low = mid + 1; } Ordering::Equal | Ordering::Greater => { high = mid; } } } low } fn upper_bound(&self, x: &T) -> usize { let mut low = 0; let mut high = self.len(); while low != high { let mid = (low + high) / 2; match self[mid].cmp(x) { Ordering::Less | Ordering::Equal => { low = mid + 1; } Ordering::Greater => { high = mid; } } } low } } impl BinarySearch for [T]{ fn lower_bound(&self, x: &T) -> usize { let mut low = 0; let mut high = self.len(); while low != high { let mid = (low + high) / 2; match self[mid].cmp(x) { Ordering::Less => { low = mid + 1; } Ordering::Equal | Ordering::Greater => { high = mid; } } } low } fn upper_bound(&self, x: &T) -> usize { let mut low = 0; let mut high = self.len(); while low != high { let mid = (low + high) / 2; match self[mid].cmp(x) { Ordering::Less | Ordering::Equal => { low = mid + 1; } Ordering::Greater => { high = mid; } } } low } } fn comb(a:usize, b:usize, fac:&Vec, ifac:&Vec)->usize{ let mut a = a; let mut b = b; if a == 0 && b == 0{return 1;} if a, ifac:&Vec)->usize{ if n == 0 && r == 0{ return 1; } return comb(n+r-1, r, fac, ifac); } fn modinv(a:usize, M:usize)->usize{ let mut b = M as i64; let mut u = 1 as i64; let mut v = 0 as i64; let mut a = a as i64; let mut m = M as i64; while(b>0){ let mut t = a/b; a -= t*b; mem::swap(&mut a, &mut b); u-=t*v; mem::swap(&mut u, &mut v); } u%=m; if u<0{u+=m;} return u as usize; } fn modpow(x:usize, n:usize) -> usize{ let mut ans = 1; let mut n = n as usize; let mut x = x; while(n != 0){ if (n&1 == 1){ans = ans*x%MODu;} x = x*x%MODu; n = n>>1; } ans } fn modpow2(x:i64, n:i64, m:i32) -> i64{ let mut ans = 1; let mut n = n as i64; let mut x = x; while(n != 0){ if (n&1 == 1){ans = ans*x%m as i64;} x = x*x%m as i64; n = n>>1; } ans } fn invs(max:usize)->(Vec, Vec){ let mut fac = vec![0;max+1]; let mut ifac = vec![0;max+1]; fac[0] = 1; ifac[0] = 1; for i in 0..max{ fac[i+1] = fac[i] * (i+1)%MODu; ifac[i+1] = ifac[i] * modpow(i+1, MODu - 2)%MODu; } (fac, ifac) } #[derive(Copy, Clone, Eq, PartialEq)] struct x{ a:i64, b:i64, c:i64, d:i64, } impl Ord for x{ fn cmp(&self, other:&Self)->Ordering{ (other.b * (self.a)).cmp(&((self.b)*other.a)) } } impl PartialOrd for x { fn partial_cmp(&self, other: &Self) -> Option { Some(self.cmp(other)) } } fn gcd(a:usize, b:usize)->usize{ if b==0{return a;} return gcd(b, a%b); } fn prime_factor(n:usize)->HashMap{ let mut res = HashMap::new(); let mut n = n; for i in 2..n{ if i*i>n{break;} while(n%i==0){ *res.entry(i).or_insert(0)+=1; n/=i; } } if n != 1{ res.insert(n, 1); } res } fn usize_multiply_is_overflow(a:usize, b:usize)->bool{ if a usize{ let mut ans = 1; let mut n = n; let mut x = x; while(n != 0){ if (n&1 == 1){ if usize_multiply_is_overflow(ans, x){ return 0; } ans = ans*x; } n = n>>1; if n == 0{ break; } if usize_multiply_is_overflow(x, x){ return 0; } x = x*x; } ans } fn tmp(x:usize, y:usize)->usize{ let mut ub = x+1; let mut lb = 1; while(ub-lb>1){ let mut mid = (ub+lb)/2; let mut now = pow2(mid, y); let mut ok = true; if now == 0{ ok = false; } if now>x { ok = false; } if ok{ lb = mid; } else{ ub = mid; } } return lb; } fn solve(){ let sssss = std::io::stdin(); let mut sc = Scanner { stdin: sssss.lock() }; let mut A:usize = sc.read(); let mut B:usize = sc.read(); let mut X:i64 = sc.read(); let mut Y:i64 = sc.read(); let (fac, ifac) = invs(1000001); let mut plus = B/4; let mut minus = B/4; if B%4 == 0{ plus+=1; } else if B%4==1{ plus+=1; } else if B%4 == 2{ plus+=1; minus+=1; } else{ plus+=1; minus+=1; } let mut v = vec![0;A+1]; for i in 0..A+1{ let mut j = X-i as i64; if j>0{ continue; } j*=-1; let mut j = j as usize; if i+j>A{ continue; } v[i+j] = nHr(plus, i, &fac, &ifac) * nHr(minus, j, &fac, &ifac)%MODu; } let mut plus = B/4; let mut minus = B/4; if B%4 == 0{ } else if B%4==1{ plus+=1; } else if B%4 == 2{ plus+=1; } else{ plus+=1; minus+=1; } let mut v2 = vec![0;A+1]; for i in 0..A+1{ let mut j = Y-i as i64; if j>0{ continue; } j*=-1; let mut j = j as usize; if i+j>A{ continue; } v2[i+j] = nHr(plus, i, &fac, &ifac) * nHr(minus, j, &fac, &ifac)%MODu; } let mut res = 0; for i in 0..A+1{ res += v[i]*v2[A-i]%MODu; res %= MODu; } println!("{}", res); } fn main(){ solve(); } const PI:f64 = std::f64::consts::PI; pub static MOD:i64 = 998244353; pub static MODu:usize = 1000000007; pub static MODi32:i32 = 1000000007; pub static eps:f64 = 1e-6; const INF: i64 = 1 << 60; const INFu:usize = 1<<62; const INFu128:u128 = 1<<126;