// Go in my style.
// Not afraid to dark.

#include <bits/stdc++.h>
using namespace std;

clock_t start_time, end_time;
#define GET_START start_time = clock ();
#define GET_END end_time = clock (); fprintf (stderr, "TIME COSSEMED : %0.3lf\n", 1.0 * (end_time - start_time) / CLOCKS_PER_SEC);
#define inline __inline__ __attribute__ ((always_inline))

#define int long long

namespace io {
    int read_pos, read_dt; char read_char;
    inline int read (int &p = read_pos){
        p = 0, read_dt = 1; read_char = getchar ();
        while (! isdigit (read_char)){
            if (read_char == '-')
                read_dt = - 1;
            read_char = getchar ();
        }
        while (isdigit (read_char)){
            p = (p << 1) + (p << 3) + read_char - 48;
            read_char = getchar ();
        }
        return p = p * read_dt;
    }
    int write_sta[65], write_top;
    inline void write (int x){
        if (x < 0)
            putchar ('-'), x = - x;
        write_top = 0;
        do
            write_sta[write_top ++] = x % 10, x /= 10;
        while (x);
        while (write_top)
            putchar (write_sta[-- write_top] + 48);
    }
}

const int N = 2e2, mod = 998244353;

#define log2_(x) (31 ^ __builtin_clz (x))

int n, m, t, r, c, v;
inline int power (int a, int p){
    static int res; res = 1;
    while (p > 0){
        if (p & 1) res = res * a % mod;
        a = a * a % mod;
        p >>= 1;
    }
    return res;
}

struct matrix {
    int a[N + 5][N + 5];
    inline int* operator [] (const int x){ return a[x]; }
    matrix (int x = 0){
        for (int i = 1;i <= N;++ i)
            for (int j = 1;j <= N;++ j)
                a[i][j] = i == j ? x : 0;
    }
    inline int det (int n){
        static int b[N + 5][N + 5];
        for (int i = 1;i <= n;++ i) for (int j = 1;j <= n;++ j) b[i][j] = a[i][j];
        for (int i = 1;i <= n;++ i){
            if (b[i][i] == 0)
                for (int j = i + 1;j <= n;++ j)
                    if (b[j][i]){
                        for (int k = i;k <= n;++ k)
                            swap (b[i][k], b[j][k]);
                        break;
                    }
            if (b[i][i] == 0) return 0;
            int iv = power (b[i][i], mod - 2);
            for (int j = i + 1;j <= n;++ j)
                if (b[j][i])
                    for (int k = n;k >= i;-- k)
                        b[j][k] = (b[j][k] + mod - b[i][k] * b[j][i] % mod * iv % mod) % mod;
        }
        int ans = 1;
        for (int i = 1;i <= n;++ i) ans = ans * b[i][i] % mod;
        return ans;
    }
    inline void Get (int n){
        for (int i = 0;i < n;++ i){
            if (a[i][i] == 0)
                for (int j = i + 1;j < n;++ j)
                    if (a[j][i]){
                        for (int k = i;k <= n;++ k)
                            swap (a[i][k], a[j][k]);
                        break;
                    }
            if (a[i][i] == 0) return void ();
            int iv = power (a[i][i], mod - 2);
            for (int j = i;j <= n;++ j)
                a[i][j] = a[i][j] * iv % mod;
            for (int j = i + 1;j < n;++ j)
                if (a[j][i])
                    for (int k = n;k >= i;-- k)
                        a[j][k] = (a[j][k] + mod - a[i][k] * a[j][i] % mod) % mod;
        }
        for (int i = n - 1;i > 0;-- i)
            for (int j = i - 1;j >= 0;-- j)
                a[j][n] = (a[j][n] + mod - a[j][i] * a[i][n] % mod) % mod, a[j][i] = 0;
    }
} M;

int rid[N * 4 + 5];

int cnta[N * 2 + 5][N * 2 + 5], cntb[N * 2 + 5][N * 2 + 5];
int ff[N * 2 + 5];

int inv[N * 4 + 5], inj[N * 4 + 5], jc[N * 4 + 5];

inline int C (int a, int b){
    if (b < 0 || b > a) return 0;
    return jc[a] * inj[b] % mod * inj[a - b] % mod;
}
inline int getC (int x, int y){ return (x < 0 || y < 0) ? 0 : C (x + y, x); }

inline int geta (int i, int j){
    if (n + i - j < 0) return 0;
    if (m - i + j < 0) return 0;
    return cnta[n + i - j][m - i + j];
}
inline int getb (int i, int j){
    if (n + i - j < 0) return 0;
    if (m - i + j < 0) return 0;
    return cntb[n + i - j][m - i + j];
}

signed main (){
    GET_START

    io::read (n), io::read (m), io::read (t) ,io::read (r), io::read (c), io::read (v);
    inv[1] = inj[0] = inj[1] = jc[0] = jc[1] = 1;
    for (int i = 2;i <= n + m + t;++ i){
        inv[i] = inv[i - mod % i] * (mod / i + 1) % mod;
        inj[i] = inj[i - 1] * inv[i] % mod;
        jc[i] = jc[i - 1] * i % mod;
    }
    c = m - c;
    int x, y, s;
	x = r + v - 1;
	y = c - v + 1;
	s = x + y;
	for(int i = 1; i < t; i++)
		for(int j = 1; j < t; j++)
		{
			for(int o = 0; o < x; o++)
				cntb[i][j] = (cntb[i][j] + getC (o - i, s - o + i) * getC (n + j - o, m - j - s + o)) % mod;
			for(int o = x + 1; o <= s + i; o++)
				cnta[i][j] = (cnta[i][j] + getC (o - i, s - o + i) * getC (n + j - o, m - j - s + o)) % mod;
		}
    for (int i = 0;i < t;++ i){
        for (int x = 1;x < t;++ x)
            for (int y = 1;y < t;++ y)
                M[x][y] = (cnta[x][y] + cntb[x][y] * i) % mod;
        ff[i] = M.det (t - 1);
    }
    for (int i = 0;i < t;++ i){
        for (int j = 0, pw = 1;j < t;++ j, pw = pw * i % mod)
            M[i][j] = pw;
        M[i][t] = ff[i];
    }
    M.Get (t);
    io::write (M[v - 1][t]), putchar ('\n');

    GET_END
    return 0;
}