#include <bits/stdc++.h>

using namespace std;

using ll = long long;

const int mod = 998244353;
int norm(int x) { return x >= mod ? x - mod : x; }
int reduce(int x) { return x < 0 ? x + mod : x; }
int neg(int x) { return x ? mod - x : 0; }
void add(int &x, int y) { if ((x += y - mod) < 0) x += mod; }
void sub(int &x, int y) { if ((x -= y) < 0) x += mod; }
int mpow(int a, int b) {
  int ret = 1;
  for (; b; b >>= 1) {
    if (b & 1) ret = (ll)ret * a % mod;
    a = (ll)a * a % mod;
  }
  return ret;
}

namespace Matrix {

  const int N = 100;

  template<class T>
  vector<int> charPoly(int n, T mat) {
    static int a[N + 5][N + 5], poly[N + 5][N + 5];
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = neg(mat[i][j]);
    for (int i = 1; i < n; ++i) {
      int pivot = i + 1;
      for (; pivot <= n && !a[pivot][i]; ++pivot);
      if (pivot > n) continue;
      if (pivot > i + 1) {
        for (int j = i; j <= n; ++j) swap(a[i + 1][j], a[pivot][j]);
        for (int j = 1; j <= n; ++j) swap(a[j][i + 1], a[j][pivot]);
      }
      int nv = mpow(a[i + 1][i], mod - 2);
      for (int j = i + 2; j <= n; ++j)
        if (a[j][i]) {
          int t = (ll)a[j][i] * nv % mod;
          for (int k = i; k <= n; ++k) a[j][k] = (a[j][k] + (ll)(mod - t) * a[i + 1][k]) % mod;
          for (int k = 1; k <= n; ++k) a[k][i + 1] = (a[k][i + 1] + (ll)t * a[k][j]) % mod;
        }
    }
    poly[n + 1][0] = 1;
    for (int i = n; i; --i) {
      poly[i][0] = 0;
      for (int j = 1; j <= n + 1 - i; ++j) poly[i][j] = poly[i + 1][j - 1];
      for (int j = i, t = 1; j <= n; ++j) {
        int coe = (ll)t * a[i][j] % mod;
        if ((j - i) & 1) coe = neg(coe);
        for (int k = 0; k <= n - j; ++k) poly[i][k] = (poly[i][k] + (ll)coe * poly[j + 1][k]) % mod;
        t = (ll)t * a[j + 1][j] % mod;
      }
    }
    return vector<int>(poly[1], poly[1] + n + 1);
  }

  template<class T>
  int det(int n, T mat) {
    static int a[N + 5][N + 5];
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = mat[i][j];
    int ret = 1;
    for (int i = 1; i <= n; ++i) {
      int pivot = i;
      for (; pivot <= n && !a[pivot][i]; ++pivot);
      if (pivot > n) return 0;
      if (pivot > i) {
        ret = mod - ret;
        for (int j = i; j <= n; ++j) swap(a[i][j], a[pivot][j]);
      }
      int nv = mpow(a[i][i], mod - 2);
      for (int j = i + 1; j <= n; ++j)
        if (a[j][i]) {
          int t = (ll)a[j][i] * nv % mod;
          for (int k = i; k <= n; ++k) a[j][k] = (a[j][k] + (ll)(mod - t) * a[i][k]) % mod;
        }
    }
    for (int i = 1; i <= n; ++i) ret = (ll)ret * a[i][i] % mod;
    return ret;
  }

  template<class T>
  vector<int> det(int n, T matA, T matB) {
    static int a[N + 5][N + 5], b[N + 5][N + 5];
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = matA[i][j], b[i][j] = matB[i][j];
    int offset = 0, coe = 1;
    for (int i = 1; i <= n; ++i) {
      for (int j = 1; j < i; ++j) {
        int t = b[j][i];
        for (int k = 1; k <= n; ++k)
          a[k][i] = (a[k][i] + (ll)(mod - t) * a[k][j]) % mod,
          b[k][i] = (b[k][i] + (ll)(mod - t) * b[k][j]) % mod;
      }
      int pivot = i;
      for (; pivot <= n && !b[pivot][i]; ++pivot);
      if (pivot > n) {
        ++offset;
        for (int j = 1; j <= n; ++j) b[j][i] = a[j][i], a[j][i] = 0;
        for (int j = 1; j < i; ++j) {
          int t = b[j][i];
          for (int k = 1; k <= n; ++k)
            a[k][i] = (a[k][i] + (ll)(mod - t) * a[k][j]) % mod,
            b[k][i] = (b[k][i] + (ll)(mod - t) * b[k][j]) % mod;
        }
        pivot = i;
        for (; pivot <= n && !b[pivot][i]; ++pivot);
        if (pivot > n) return {};
      }
      if (pivot > i) {
        coe = mod - coe;
        for (int j = 1; j <= n; ++j)
          swap(a[i][j], a[pivot][j]), swap(b[i][j], b[pivot][j]);
      }
      coe = (ll)coe * b[i][i] % mod;
      int nv = mpow(b[i][i], mod - 2);
      for (int j = 1; j <= n; ++j)
        a[i][j] = (ll)a[i][j] * nv % mod, b[i][j] = (ll)b[i][j] * nv % mod;
      for (int j = i + 1; j <= n; ++j)
        if (b[j][i]) {
          int t = b[j][i];
          for (int k = 1; k <= n; ++k)
            a[j][k] = (a[j][k] + (ll)(mod - t) * a[i][k]) % mod,
            b[j][k] = (b[j][k] + (ll)(mod - t) * b[i][k]) % mod;
        }
    }
    for (int i = 1; i <= n; ++i) for (int j = 1; j <= n; ++j) a[i][j] = neg(a[i][j]), assert(b[i][j] == (i == j));
    auto res = charPoly(n, a);
    vector<int> ret(n - offset + 1);
    for (int i = 0; i <= n - offset; ++i)
      ret[i] = (ll)coe * res[i + offset] % mod;
    return ret;
  }

}

using Matrix::charPoly;
using Matrix::det;

const int N = 400;
const int K = 100;

int n, m, k, r, c, v;
int binom[N + 5][N + 5];
int a[K + 5][K + 5], b[K + 5][K + 5];

int main() {
  scanf("%d%d%d%d%d%d", &n, &m, &k, &r, &c, &v);
  if (k == 1) { puts("1"); return 0; }
  for (int i = 0; i <= n + m; ++i) {
    binom[i][0] = 1;
    for (int j = 1; j <= i; ++j) add(binom[i][j] = binom[i - 1][j], binom[i - 1][j - 1]);
  }
  r -= k - v, c -= k - v;
  for (int i = 1; i < k; ++i)
    for (int j = 1; j < k; ++j) {
      int x = n + j - i, y = m + i - j, u = r - n + i - 1 + x, v = c + i - 1;
      if (x < 0 || y < 0) continue;
      if (u <= 0 || v <= 0) b[i][j] = 0;
      else if (u > x || v > y) b[i][j] = binom[x + y][x];
      else {
        if (u <= v)
          for (int k = 0; k < u; ++k) b[i][j] = (b[i][j] + (ll)binom[x + v - u][x - k] * binom[y - v + u][k]) % mod;
        else
          for (int k = 0; k < v; ++k) b[i][j] = (b[i][j] + (ll)binom[x + v - u][k] * binom[y - v + u][y - k]) % mod;
      }
      a[i][j] = binom[x + y][x];
      if (u >= 0 && v >= 0 && u <= x && v <= y) a[i][j] = (a[i][j] + (ll)(mod - binom[x - u + v][v]) * binom[y - v + u][u]) % mod;
      sub(a[i][j], b[i][j]);
    }
  auto res = det(k - 1, a, b);
  if (res.size() >= v) printf("%d\n", res[v - 1]);
  else puts("0");
}