#[allow(unused_imports)] use std::{collections::*, cmp::*, ops::*};

// https://cdn.discordapp.com/attachments/1079781449621852230/1175811206091645078/SPOILER_image.png?ex=656c9685&is=655a2185&hm=5cdeb3d3a68a9dcd341c04463a941c77e127d84b7cf4b599d06fdc105047c407&
fn main() {
	let mut oj = OJ::new();
	
	let n = oj.usize();
	let m = oj.usize(); // n*m
	let k = oj.usize()-1; // k layers
	let r = oj.usize();
	let c = oj.usize();
	let v = oj.usize(); // A[r,c] = v

	// i-th start is (i+1, k-1-i)
	// i-th end is (m+i+1, n+k-1-i)
	// cell (i,j)'s upper left corner is (j, n+k-i)
	// target cell is (r+v, c+v-1)
	// target cell's upper left corner is (c+v-2, n+k+2-r-v)
	let targ_x = c+v-2;
	let targ_y = n+k+2-r-v;

	let mf = Modfact::new(1000);
	let mut mat_x = SquareMatrix::<Modint>::new(k);
	let mut mat_1 = SquareMatrix::<Modint>::new(k);
	for i in 0..k {
		let xstart = i+1;
		let ystart = k-1-i;
		for j in 0..k {
			let xend = m+j+1;
			let yend = n+k-1-j;
			if xstart > xend || ystart > yend { continue; }
			// cross the target diagonal (x+y = targ_x+targ_y) at y
			for y in ystart..=yend {
				if targ_x + targ_y < y { continue; }
				let x = targ_x + targ_y - y;
				if !(xstart..=xend).contains(&x) { continue; }

				// count ways
				let w = x - xstart; let h = y - ystart;
				let ways1 = mf.comb(w+h, w);
				let w = xend - x; let h = yend - y;
				let ways2 = mf.comb(w+h, w);
				let ways = ways1 * ways2;

				// add to appropriate matrix
				if y >= targ_y { mat_x[i][j] += ways; }
				else if y+1 == targ_y { }
				else { mat_1[i][j] += ways; }
			}
		}
	}

	let poly = SquareMatrix::det_axb(&mut mat_x, &mut mat_1);
	oj.write(poly.get(v-1).unwrap_or(&modint(0)));
}

///////////////////////////////////////

pub mod square_matrix_mod {
	use std::{ops::*, fmt::*, mem::take};

	pub trait Semiring:
		Neg<Output=Self>
		+ AddAssign + Add<Output=Self> + MulAssign + Mul<Output=Self>
		+ Clone + Default + From<i32> + PartialEq + Display + Debug {}
	impl<T> Semiring for T where T:
		Neg<Output=Self>
		+ AddAssign + Add<Output=Self> + MulAssign + Mul<Output=Self>
		+ Clone + Default + From<i32> + PartialEq + Display + Debug {}

	/// A square matrix.
	#[derive(Debug, Clone, Eq, PartialEq, Default)]
	pub struct SquareMatrix<T> { pub mat: Vec<Vec<T>> }

	impl<T> SquareMatrix<T> {
		/// Creates an empty `n * n` matrix.
		pub fn new(n: usize) -> Self where T: Clone + Default {
			Self { mat: vec![vec![T::default(); n]; n] }
		}
		/// Cretaes a matrix out of `n * n` values.
		pub fn from_line(n: usize, vals: &[T]) -> Self where T: Clone {
			assert!(vals.len() == n*n);
			if n == 0 { return Self { mat: vec![] }; }
			Self { mat: vals.chunks(n).map(<[T]>::to_vec).collect() }
		}
		/// Creates an identity `n * n` matrix.
		pub fn eye(n: usize) -> Self where T: Clone + Default + From<i32> {
			let mut mat = Self::new(n);
			for i in 0..n { mat[i][i] = 1.into(); }
			mat
		}

		/// Returns `n`.
		pub fn n(&self) -> usize { self.mat.len() }

		/// Iterates over its elements.
		pub fn elements(&self) -> impl Iterator<Item = &T> {
			self.mat.iter().flat_map(|row| row.iter())
		}
		/// Iterates over its owned elements.
		pub fn into_elements(self) -> impl Iterator<Item = T> {
			self.mat.into_iter().flat_map(IntoIterator::into_iter)
		}
		/// Iterates mutably over its elements.
		pub fn elements_mut(&mut self) -> impl Iterator<Item = &mut T> {
			self.mat.iter_mut().flat_map(|row| row.iter_mut())
		}
	}

	// io
	impl<T: Display> Display for SquareMatrix<T> {
		fn fmt(&self, f: &mut Formatter) -> Result {
			for row in &self.mat {
				for x in row { write!(f, "{} ", x)?; }
				writeln!(f)?;
			}
			Ok(())
		}
	}

	// indexing
	/// Returns the `i`-th row.
	impl<T> Index<usize> for SquareMatrix<T> { type Output = [T];
		fn index(&self, i: usize) -> &Self::Output { &self.mat[i] }
	}
	/// Returns the `i`-th row mutably.
	impl<T> IndexMut<usize> for SquareMatrix<T> {
		fn index_mut(&mut self, i: usize) -> &mut Self::Output { &mut self.mat[i] }
	}

	// arithmetic
	impl<T: Neg<Output = T> + Default> Neg for SquareMatrix<T> {
		type Output = Self;
		fn neg(mut self) -> Self::Output {
			self.elements_mut().for_each(|x| *x = -take(x));
			self
		}
	}
	impl<T: AddAssign> AddAssign for SquareMatrix<T> {
		fn add_assign(&mut self, b: Self) {
			assert_eq!(self.n(), b.n(), "Matrix sizes mismatch");
			self.elements_mut().zip(b.into_elements()).for_each(|(x, y)| *x += y);
		}
	}
	impl<T: Add<Output = T> + Default> Add for SquareMatrix<T> { type Output = Self;
		fn add(mut self, b: Self) -> Self {
			assert_eq!(self.n(), b.n(), "Matrix sizes mismatch");
			self.elements_mut().zip(b.into_elements())
				.for_each(|(x, y)| *x = take(x) + y);
			self
		}
	}
	impl<T: SubAssign> SubAssign for SquareMatrix<T> {
		fn sub_assign(&mut self, b: Self) {
			assert_eq!(self.n(), b.n(), "Matrix sizes mismatch");
			self.elements_mut().zip(b.into_elements()).for_each(|(x, y)| *x -= y);
		}
	}
	impl<T: Sub<Output = T> + Default> Sub for SquareMatrix<T> { type Output = Self;
		fn sub(mut self, b: Self) -> Self {
			assert_eq!(self.n(), b.n(), "Matrix sizes mismatch");
			self.elements_mut().zip(b.into_elements())
				.for_each(|(x, y)| *x = take(x) - y);
			self
		}
	}
	impl<T: MulAssign + Clone> MulAssign<T> for SquareMatrix<T> {
		fn mul_assign(&mut self, k: T) {
			self.elements_mut().for_each(|x| *x *= k.clone());
		}
	}
	impl<T: Mul<Output = T> + Default + Clone> Mul<T> for SquareMatrix<T> {
		type Output = Self;
		fn mul(mut self, k: T) -> Self {
			self.elements_mut().for_each(|x| *x = take(x) * k.clone());
			self
		}
	}
	impl<T: Semiring> MulAssign for SquareMatrix<T> {
		fn mul_assign(&mut self, b: Self) { *self = take(self) * b; }
	}
	impl<T: Semiring> Mul for SquareMatrix<T> {
		type Output = Self;
		fn mul(self, b: Self) -> Self {
			assert_eq!(self.n(), b.n(), "Matrix sizes mismatch");
			let mut ans = Self::new(self.n());
			for (j, bj) in b.mat.iter().enumerate() {
			for (ai, si) in ans.mat.iter_mut().zip(self.mat.iter()) {
			for (aik, bjk) in ai.iter_mut().zip(bj.iter()) {
				unsafe { *aik += si.get_unchecked(j).clone() * bjk.clone(); }
			}}}
			ans
		}
	}
	impl<T: Semiring> SquareMatrix<T> {
		/// Returns its `k`-th power.
		pub fn pow(&self, mut k: u64) -> Self {
			let mut ans = Self::eye(self.n());
			let mut a = self.clone();
			while k != 0 {
				if k&1 == 1 { ans*= a.clone(); }
				k>>= 1; a*= a.clone();
			}
			ans
		}
	}
} pub use square_matrix_mod::SquareMatrix;

pub mod gauss_elim_mod {
	use std::ops::Div;
	use super::square_matrix_mod::{Semiring, *};

	pub trait Field: Semiring + Div<Output=Self> {}
	impl<T> Field for T where T: Semiring + Div<Output=Self> {}

	impl<T> SquareMatrix<T> where T: Semiring {
		pub fn swap_row(&mut self, i: usize, j: usize) -> bool {
			if i == j { false }
			else { self.mat.swap(i, j); true }
		}
		pub fn swap_col(&mut self, i: usize, j: usize) -> bool {
			if i == j { false }
			else { for row in &mut self.mat { row.swap(i, j); } true }
		}
		pub fn mul_row(&mut self, i: usize, k: T) {
			for x in &mut self[i] { *x *= k.clone(); }
		}
		pub fn mul_col(&mut self, j: usize, k: T) {
			for row in &mut self.mat { row[j] *= k.clone(); }
		}
		pub fn add_row(&mut self, fr: usize, k: T, to: usize) {
			assert_ne!(fr, to, "Bad row-add");
			let row = std::mem::take(&mut self.mat[fr]);
			for (x, y) in self.mat[to].iter_mut().zip(row.iter()) {
				*x += k.clone() * y.clone();
			}
			self.mat[fr] = row;
		}
		pub fn add_col(&mut self, fr: usize, k: T, to: usize) {
			assert_ne!(fr, to, "Bad col-add");
			for row in &mut self.mat {
				let v = row[fr].clone();
				row[to] += k.clone() * v;
			}
		}
	}

	impl<T: Field> SquareMatrix<T> {
		pub fn make_ref(&mut self) -> T {
			let n = self.n();
			let mut istart = 0;
			let mut det: T = 1.into();
			for j in 0..n {
				// Find and swap pivot
				let mut piv = istart;
				while piv < n && self[piv][j] == T::default() { piv += 1; }
				if piv == n { continue; }
				if istart != piv {
					det = -det; self.swap_row(istart, piv);
				}
				// Zero the other rows
				let v = self.mat[istart][j].clone();
				det *= v.clone();
				self.mul_row(istart, T::from(1) / v);
				for i in istart+1..n {
					let v = self.mat[i][j].clone();
					self.add_row(istart, -v, i);
				}
				istart += 1;
			}
			for i in 0..n { det *= self.mat[i][i].clone(); }
			det
		}
	}
}

pub mod char_poly_mod {
	use super::SquareMatrix;
	use super::gauss_elim_mod::Field;

	impl<T: Field> SquareMatrix<T> {
		/// Transforms it into upper Hessenberg form.
		pub fn make_hessenberg(&mut self) {
			let n = self.n();
			for piv in 1..n {
				// find pivot and swap
				let mut i = piv;
				while i < n {
					if self[i][piv-1] != T::default() { break; }
					i += 1;
				}
				if i == n { continue; }
				self.swap_row(i, piv); self.swap_col(i, piv);
				// zero other rows
				let x = T::from(1) / self[piv][piv-1].clone();
				for i in i+1..n {
					let mul = self[i][piv-1].clone() * x.clone();
					self.add_row(piv, -mul.clone(), i);
					self.add_col(i, mul, piv);
				}
			}
		}

		/// Transforms it into upper Hessenberg form and returns det(xI + A).
		pub fn make_hessenberg_det_xia(&mut self) -> Vec<T> {
			self.make_hessenberg();
			let mut dets = vec![vec![T::from(1)]];
			let mut det = vec![T::from(1)];
			let n = self.n();
			for k in 0..n {
				let mut q = vec![T::default()];
				q.append(&mut det.clone());
				for (x, y) in q.iter_mut().zip(det.iter()) {
					*x += self[k][k].clone() * y.clone();
				}
				det = q;
				let mut prod = T::from(1);
				for i in (0..k).rev() {
					prod *= -self[i+1][i].clone();
					let z = self[i][k].clone() * prod.clone();
					let add = &dets[i];
					for (x, y) in det.iter_mut().zip(add.iter()) {
						*x += y.clone() * z.clone();
					}
				}
				dets.push(det.clone());
			}
			det
		}

		/// Returns det(Ax + B).
		// https://tistory.joonhyung.xyz/19
		pub fn det_axb(a: &mut Self, b: &mut Self) -> Vec<T> {
			let n = a.n();
			assert_eq!(n, b.n(), "Matrix sizes mismatch");

			let (mut alpha, mut beta) = (0, 0);
			let mut det = T::from(1);
			while alpha + beta < n {
				for i in 0..alpha {
					b.add_col(i, -a[i][alpha].clone(), alpha);
					a.add_col(i, -a[i][alpha].clone(), alpha);
				}
				for i in alpha..n-beta {
					if a[i][alpha] != T::default() {
						if a.swap_row(alpha, i) { det = -det; }
						b.swap_row(alpha, i);
						break;
					}
				}
				if a[alpha][alpha] != T::default() {
					det *= a[alpha][alpha].clone();
					let v = T::from(1) / a[alpha][alpha].clone();
					a.mul_row(alpha, v.clone()); b.mul_row(alpha, v);
					for i in alpha+1..n {
						b.add_row(alpha, -a[i][alpha].clone(), i);
						a.add_row(alpha, -a[i][alpha].clone(), i);
					}
					alpha += 1;
				}
				else {
					let r = n-1-beta;
					if a.swap_col(alpha, r) { det = -det; }
					b.swap_col(alpha, r);
					let mut pos = None;
					for i in (0..=r).rev() {
						if b[i][r] != T::default() { pos = Some(i); break; }
					}

					let Some(pos) = pos else { return vec![]; };
					if pos < alpha {
						a.swap_row(pos, alpha-1); b.swap_row(pos, alpha-1);
						a.swap_col(pos, alpha-1); b.swap_col(pos, alpha-1);
						if a.swap_row(alpha-1, r) { det = -det; }
						b.swap_row(alpha-1, r);
						alpha -= 1;
					}
					else {
						if a.swap_row(pos, r) { det = -det; }
						b.swap_row(pos, r);
					}
					det *= b[r][r].clone();
					let v = T::from(1) / b[r][r].clone();
					a.mul_row(r, v.clone()); b.mul_row(r, v);
					for i in 0..r {
						a.add_row(r, -b[i][r].clone(), i);
						b.add_row(r, -b[i][r].clone(), i);
					}
					beta += 1;
				}
			}

			let mut c = SquareMatrix::new(alpha);
			for i in 0..alpha { for j in 0..alpha {
				c[i][j] = b[i][j].clone();
			}}
			let mut poly = c.make_hessenberg_det_xia();
			poly.iter_mut().for_each(|x| *x *= det.clone());
			poly
		}
	}
}

pub mod modint_998244353 {
	pub const MOD: i32 = 998244353;
	pub const MODL: i64 = MOD as i64;
	
	use std::ops::*;
	use std::fmt::*;
	
	#[derive(Default, Debug, Copy, Clone, Eq, PartialEq, Ord, PartialOrd)]
	pub struct Modint { v: i32 }
	pub fn modint(v: i64) -> Modint { Modint::new(v) }
	
	impl Modint {
		pub fn new(v: i64) -> Modint { Self { v: v.rem_euclid(MODL) as i32 } }
	
		pub fn pow(&self, mut n: u64) -> Self {
			let mut ans = Modint::new(1);
			let mut a = *self;
			while n != 0 {
				if n&1 == 1 { ans*= a; }
				n>>= 1; a*= a;
			}
			ans
		}
	
		pub fn inv(&self) -> Self {
			assert!(self.v != 0, "Cannot invert 0");
			self.pow((MOD-2) as u64)
		}
	}
	
	// io
	impl std::str::FromStr for Modint {
		type Err = std::num::ParseIntError;
		fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
			Ok(Self::new(s.parse::<i64>()?))
		}
	}
	impl Display for Modint {
		fn fmt(&self, f: &mut Formatter) -> Result { write!(f, "{}", self.v) }
	}
	impl From<Modint> for i32 {
		fn from(num: Modint) -> i32 { num.v }
	}
	impl From<i32> for Modint {
		fn from(num: i32) -> Modint { Modint::new(num as i64) }
	}
	
	// arithmetic
	impl AddAssign for Modint {
		fn add_assign(&mut self, b: Self) {
			self.v+= b.v; if self.v >= MOD { self.v-= MOD; }
		}
	}
	impl Add for Modint { type Output = Self;
		fn add(self, b: Self) -> Self { let mut z = self; z+= b; z }
	}
	impl Neg for Modint { type Output = Self;
		fn neg(self) -> Self { Self::default() - self }
	}
	impl SubAssign for Modint {
		fn sub_assign(&mut self, b: Self) {
			self.v-= b.v; if self.v < 0 { self.v+= MOD; }
		}
	}
	impl Sub for Modint { type Output = Self;
		fn sub(self, b: Self) -> Self { let mut z = self; z-= b; z }
	}
	impl MulAssign for Modint {
		fn mul_assign(&mut self, b: Self) {
			self.v = ((self.v as i64) * (b.v as i64) % MODL) as i32;
		}
	}
	impl Mul for Modint { type Output = Self;
		fn mul(self, b: Self) -> Self { let mut z = self; z*= b; z }
	}
	impl DivAssign for Modint {
		fn div_assign(&mut self, b: Self) { *self = *self / b; }
	}
	#[allow(clippy::suspicious_arithmetic_impl)]
	impl Div for Modint { type Output = Self;
		fn div(self, b: Self) -> Self { self * b.inv() }
	}
	
	// factorial
	#[derive(Clone, Debug, Default)]
	pub struct Modfact {
		pub fact: Vec<Modint>,
		pub ifact: Vec<Modint>,
	}
	
	impl Modfact {
		pub fn new(n: usize) -> Self {
			let mut fact = vec![modint(1)];
			for i in 1..=n {
				fact.push(fact[i-1] * modint(i as i64));
			}
			let mut ifact = vec![fact[n].inv(); n+1];
			for i in (0..n).rev() {
				ifact[i] = ifact[i+1] * modint((i+1) as i64);
			}
			Self { fact, ifact }
		}
		pub fn len(&self) -> usize { self.fact.len() }
	
		pub fn comb(&self, n: usize, r: usize) -> Modint {
			assert!(r <= n && n < self.len(),
				"Bad comb-query values ({}, {})", n, r
			);
			self.fact[n] * self.ifact[r] * self.ifact[n-r]
		}
	}	
}
pub use modint_998244353::{MOD, MODL, Modint, Modfact, modint};


pub mod oj_default_mod {
	use std::{fmt::{Display, Debug}, io::*, process::*, str::*};

	pub struct OJ {
		buffer: std::str::SplitWhitespace<'static>,
		out: BufWriter<Stdout>
	}
	
	impl OJ {
		#[allow(clippy::new_without_default)]
		pub fn new() -> Self {
			let mut inp = String::new();
			stdin().read_to_string(&mut inp).unwrap();
			let input = Box::leak(inp.into_boxed_str()).split_whitespace();
			Self { buffer: input, out: BufWriter::new(stdout()) }
		}
	
		pub fn try_read<T: FromStr>(&mut self) -> std::result::Result<T, &str> {
			self.buffer.next().ok_or("EOF")?
				.parse().or(Err("Failed parse"))
		}
		pub fn read<T: FromStr>(&mut self) -> T { self.try_read().unwrap() }
		pub fn i32(&mut self) -> i32 { self.read() }
		pub fn i64(&mut self) -> i64 { self.read() }
		pub fn u32(&mut self) -> u32 { self.read() }
		pub fn u64(&mut self) -> u64 { self.read() }
		pub fn usize(&mut self) -> usize { self.read() }
		pub fn f64(&mut self) -> f64 { self.read() }
		pub fn string(&mut self) -> String { self.read() }

		pub fn read_vec<T: FromStr>(&mut self, n: usize) -> Vec<T>
			{ (0..n).map(|_| self.read()).collect() }
		pub fn read_grid<T: FromStr>(&mut self, n: usize, m: usize) -> Vec<Vec<T>>
			{ (0..n).map(|_| self.read_vec(m)).collect() }

		pub fn write<T: Display>(&mut self, v: T) -> &mut Self
			{ write!(self.out, "{v}").unwrap(); self }
		pub fn writes<T: Display>(&mut self, vals: &[T]) -> &mut Self
			{ for v in vals { self.write(v).sp(); } self }
		pub fn debug<T: Debug>(&mut self, v: T) -> &mut Self
			{ write!(self.out, "{v:?}").unwrap(); self }
		pub fn sp(&mut self) -> &mut Self { self.write(' ') }
		pub fn ln(&mut self) -> &mut Self { self.write('\n') }
		pub fn quit<T: Display>(&mut self, v: T) -> !
			{ self.write(v); self.out.flush().unwrap(); exit(0) }
	}
}
pub use oj_default_mod::OJ;