use std::io::Write; const MOD1: u32 = 1_000_000_007; const MOD2: u32 = 1_000_000_009; fn main() { let out = std::io::stdout(); let mut out = std::io::BufWriter::new(out.lock()); input! { t: usize, ask: [(i64, i64, i64, i64); t], } for (n, m, a, b) in ask { let x = { type Mod = ConstantModulo; type M = ModInt; let x = Solver::::new(); let v = x.find_all(n, m, a, b); let u = x.find_all(n, m, a, 0); let mut ans = M::zero(); ans += M::new(2) * v[1][1]; ans -= M::from(n - 1) * v[0][1]; ans += u[1][1]; ans -= M::from(n) * u[0][1]; ans }; let y = { type Mod = ConstantModulo; type M = ModInt; let x = Solver::::new(); let v = x.find_all(n, m, a, b); let u = x.find_all(n, m, a, 0); let mut ans = M::zero(); ans += M::new(2) * v[1][1]; ans -= M::from(n - 1) * v[0][1]; ans += u[1][1]; ans -= M::from(n) * u[0][1]; ans }; let (a, b) = (x.0, y.0); let mut ans = 0; ans += a as u128 * pow(MOD2, MOD1 - 2, MOD1) as u128 * MOD2 as u128; ans += b as u128 * pow(MOD1, MOD2 - 2, MOD2) as u128 * MOD1 as u128; ans %= MOD1 as u128 * MOD2 as u128; writeln!(out, "{}", ans).ok(); } } fn pow(mut r: u32, mut n: u32, m: u32) -> u32 { let mut t = 1; while n > 0 { if n & 1 == 1 { t = (t as u64 * r as u64 % m as u64) as u32; } r = (r as u64 * r as u64 % m as u64) as u32; n >>= 1; } t } // ---------- begin input macro ---------- // reference: https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8 #[macro_export] macro_rules! input { (source = $s:expr, $($r:tt)*) => { let mut iter = $s.split_whitespace(); input_inner!{iter, $($r)*} }; ($($r:tt)*) => { let s = { use std::io::Read; let mut s = String::new(); std::io::stdin().read_to_string(&mut s).unwrap(); s }; let mut iter = s.split_whitespace(); input_inner!{iter, $($r)*} }; } #[macro_export] macro_rules! input_inner { ($iter:expr) => {}; ($iter:expr, ) => {}; ($iter:expr, $var:ident : $t:tt $($r:tt)*) => { let $var = read_value!($iter, $t); input_inner!{$iter $($r)*} }; } #[macro_export] macro_rules! read_value { ($iter:expr, ( $($t:tt),* )) => { ( $(read_value!($iter, $t)),* ) }; ($iter:expr, [ $t:tt ; $len:expr ]) => { (0..$len).map(|_| read_value!($iter, $t)).collect::>() }; ($iter:expr, chars) => { read_value!($iter, String).chars().collect::>() }; ($iter:expr, bytes) => { read_value!($iter, String).bytes().collect::>() }; ($iter:expr, usize1) => { read_value!($iter, usize) - 1 }; ($iter:expr, $t:ty) => { $iter.next().unwrap().parse::<$t>().expect("Parse error") }; } // ---------- end input macro ---------- struct Solver { p: Vec>>, pc: Precalc, size: usize, } impl Solver where Mod: Modulo, { pub fn new() -> Self { let size = K - 1; let mut p = vec![vec![]; 1]; let pc = Precalc::new(size + 1); p[0] = vec![ModInt::zero(), ModInt::one()]; for i in 1..=size { let mut a = vec![ModInt::zero(); i + 2]; a[i + 1] = ModInt::one(); for j in 0..i { let m = pc.binom(i + 1, j); for (a, p) in a.iter_mut().zip(p[j].iter()) { *a -= m * *p; } } let inv = pc.inv(i + 1); a.iter_mut().for_each(|a| *a *= inv); p.push(a); } Self { p: p, pc: pc, size: size, } } pub fn find_all(&self, n: i64, m: i64, a: i64, b: i64) -> [[ModInt; K]; K] { self.find_rec(n, m, a, b, self.size) } pub fn find(&self, n: i64, m: i64, a: i64, b: i64, c: usize, d: usize) -> ModInt { assert!(c + d <= self.size); self.find_all(n, m, a, b)[c][d] } fn find_rec(&self, n: i64, m: i64, a: i64, b: i64, s: usize) -> [[ModInt; K]; K] { if a >= m { let x = a.div_euclid(m); let pre = self.find_rec(n, m, a - x * m, b, s); let mut res = [[ModInt::zero(); K]; K]; for c in 0..=s { for d in 0..=(s - c) { let mut sum = ModInt::zero(); for q in (0..=d).rev() { let p = d - q; sum = ModInt::from(x) * sum + self.pc.binom(d, q) * pre[q + c][p]; } res[c][d] = sum; } } return res; } if b >= m { let y = b.div_euclid(m); let pre = self.find_rec(n, m, a, b - y * m, s); let mut res = [[ModInt::zero(); K]; K]; for c in 0..=s { for d in 0..=(s - c) { let mut sum = ModInt::zero(); for r in (0..=d).rev() { let p = d - r; sum = ModInt::from(y) * sum + self.pc.binom(d, r) * pre[c][p]; } res[c][d] = sum; } } return res; } if a * (n - 1) + b < m { let mut res = [[ModInt::zero(); K]; K]; for i in 0..=s { res[i][0] = self.p[i] .iter() .rfold(ModInt::zero(), |s, a| s * ModInt::from(n) + *a); } return res; } let pc = &self.pc; let mut res = [[ModInt::zero(); K]; K]; for i in 0..=s { res[i][0] = self.p[i] .iter() .rfold(ModInt::zero(), |s, a| s * ModInt::from(n) + *a); } let y = (a * (n - 1) + b) / m; let pre = self.find_rec(y, a, m, m - b + a - 1, s); let mut sum = (0..=s) .map(|c| vec![ModInt::zero(); s - c + 2]) .collect::>(); for c in 0..=s { for d in 0..=(s - c + 1) { let mut s = ModInt::zero(); for i in 0..d { s += pc.binom(d, i) * pre[i][c]; } sum[c][d] = s; } } for c in 0..=s { for d in 1..=(s - c) { let mut p = self.p[c].clone(); p.iter_mut().for_each(|p| *p = -*p); p[0] += self.p[c] .iter() .rfold(ModInt::zero(), |s, a| s * ModInt::from(n) + *a); for (i, p) in p.iter().enumerate() { res[c][d] += *p * sum[i][d]; } } } res } } // ---------- begin modint ---------- use std::marker::*; use std::ops::*; pub trait Modulo { fn modulo() -> u32; } pub struct ConstantModulo; impl Modulo for ConstantModulo<{ M }> { fn modulo() -> u32 { M } } pub struct ModInt(u32, PhantomData); impl Clone for ModInt { fn clone(&self) -> Self { Self::new_unchecked(self.0) } } impl Copy for ModInt {} impl Add for ModInt { type Output = ModInt; fn add(self, rhs: Self) -> Self::Output { let mut v = self.0 + rhs.0; if v >= T::modulo() { v -= T::modulo(); } Self::new_unchecked(v) } } impl AddAssign for ModInt { fn add_assign(&mut self, rhs: Self) { *self = *self + rhs; } } impl Sub for ModInt { type Output = ModInt; fn sub(self, rhs: Self) -> Self::Output { let mut v = self.0 - rhs.0; if self.0 < rhs.0 { v += T::modulo(); } Self::new_unchecked(v) } } impl SubAssign for ModInt { fn sub_assign(&mut self, rhs: Self) { *self = *self - rhs; } } impl Mul for ModInt { type Output = ModInt; fn mul(self, rhs: Self) -> Self::Output { let v = self.0 as u64 * rhs.0 as u64 % T::modulo() as u64; Self::new_unchecked(v as u32) } } impl MulAssign for ModInt { fn mul_assign(&mut self, rhs: Self) { *self = *self * rhs; } } impl Neg for ModInt { type Output = ModInt; fn neg(self) -> Self::Output { if self.is_zero() { Self::zero() } else { Self::new_unchecked(T::modulo() - self.0) } } } impl std::fmt::Display for ModInt { fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result { write!(f, "{}", self.0) } } impl std::fmt::Debug for ModInt { fn fmt<'a>(&self, f: &mut std::fmt::Formatter<'a>) -> std::fmt::Result { write!(f, "{}", self.0) } } impl Default for ModInt { fn default() -> Self { Self::zero() } } impl std::str::FromStr for ModInt { type Err = std::num::ParseIntError; fn from_str(s: &str) -> Result { let val = s.parse::()?; Ok(ModInt::new(val)) } } impl From for ModInt { fn from(val: usize) -> ModInt { ModInt::new_unchecked((val % T::modulo() as usize) as u32) } } impl From for ModInt { fn from(val: u64) -> ModInt { ModInt::new_unchecked((val % T::modulo() as u64) as u32) } } impl From for ModInt { fn from(val: i64) -> ModInt { let mut v = ((val % T::modulo() as i64) + T::modulo() as i64) as u32; if v >= T::modulo() { v -= T::modulo(); } ModInt::new_unchecked(v) } } impl ModInt { pub fn new_unchecked(n: u32) -> Self { ModInt(n, PhantomData) } pub fn zero() -> Self { ModInt::new_unchecked(0) } pub fn one() -> Self { ModInt::new_unchecked(1) } pub fn is_zero(&self) -> bool { self.0 == 0 } } impl ModInt { pub fn new(d: u32) -> Self { ModInt::new_unchecked(d % T::modulo()) } pub fn pow(&self, mut n: u64) -> Self { let mut t = Self::one(); let mut s = *self; while n > 0 { if n & 1 == 1 { t *= s; } s *= s; n >>= 1; } t } pub fn inv(&self) -> Self { assert!(!self.is_zero()); self.pow(T::modulo() as u64 - 2) } pub fn fact(n: usize) -> Self { (1..=n).fold(Self::one(), |s, a| s * Self::from(a)) } pub fn perm(n: usize, k: usize) -> Self { if k > n { return Self::zero(); } ((n - k + 1)..=n).fold(Self::one(), |s, a| s * Self::from(a)) } pub fn binom(n: usize, k: usize) -> Self { if k > n { return Self::zero(); } let k = k.min(n - k); let mut nu = Self::one(); let mut de = Self::one(); for i in 0..k { nu *= Self::from(n - i); de *= Self::from(i + 1); } nu * de.inv() } } // ---------- end modint ---------- // ---------- begin precalc ---------- pub struct Precalc { fact: Vec>, ifact: Vec>, inv: Vec>, } impl Precalc { pub fn new(n: usize) -> Precalc { let mut inv = vec![ModInt::one(); n + 1]; let mut fact = vec![ModInt::one(); n + 1]; let mut ifact = vec![ModInt::one(); n + 1]; for i in 2..=n { fact[i] = fact[i - 1] * ModInt::new_unchecked(i as u32); } ifact[n] = fact[n].inv(); if n > 0 { inv[n] = ifact[n] * fact[n - 1]; } for i in (1..n).rev() { ifact[i] = ifact[i + 1] * ModInt::new_unchecked((i + 1) as u32); inv[i] = ifact[i] * fact[i - 1]; } Precalc { fact, ifact, inv } } pub fn inv(&self, n: usize) -> ModInt { assert!(n > 0); self.inv[n] } pub fn fact(&self, n: usize) -> ModInt { self.fact[n] } pub fn ifact(&self, n: usize) -> ModInt { self.ifact[n] } pub fn perm(&self, n: usize, k: usize) -> ModInt { if k > n { return ModInt::zero(); } self.fact[n] * self.ifact[n - k] } pub fn binom(&self, n: usize, k: usize) -> ModInt { if k > n { return ModInt::zero(); } self.fact[n] * self.ifact[k] * self.ifact[n - k] } } // ---------- end precalc ----------