#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int mod=998244353;
int pw(int a,ll b,int c=1)
{
    for(;b;b>>=1,a=1ll*a*a%mod)
        if(b&1)c=1ll*c*a%mod;
    return c;
}
void add(int&a,int b){a+=b;if(a>=mod)a-=mod;}
namespace Poly
{
const int N=1<<18,g=3;
int pwg[N],iinv[N];
int getsz(int n){return 1<<__lg(n)+1;}
void init()
{
    for(int h=2;h<=N;h<<=1)
    {
        int t=pw(3,(mod-1)/h);pwg[h>>1]=1;
        for(int i=(h>>1)+1;i<h;++i)pwg[i]=1ll*pwg[i-1]*t%mod;
    }
    iinv[0]=iinv[1]=1;
    for(int i=2;i<N;++i)iinv[i]=1ll*iinv[mod%i]*(mod-mod/i)%mod;
}
void dft(vector<int>&f,int n)
{
    f.resize(n);
    for(int h=n;h>1;h>>=1)
        for(int i=0,p=h>>1;i<n;i+=h)
            for(int j=i;j<i+p;++j)
            {
                int u=f[j],v=f[j+p];
                add(f[j],v),f[j+p]=1ll*pwg[j-i+p]*(u-v+mod)%mod;
            }
}
void idft(vector<int>&f,int n)
{
    f.resize(n);
    for(int h=2;h<=n;h<<=1)
        for(int i=0,p=h>>1;i<n;i+=h)
            for(int j=i;j<i+p;++j)
            {
                int t=1ll*pwg[j-i+p]*f[j+p]%mod;
                f[j+p]=f[j],add(f[j+p],mod-t),add(f[j],t);
            }
    reverse(f.begin()+1,f.begin()+n);
    for(int i=0,k=pw(n,mod-2);i<n;++i)f[i]=1ll*f[i]*k%mod;
}
struct poly:vector<int>
{
    using vector<int>::vector;
    void modxn(int n){if(n<size())resize(n);}
    void drv()
    {
        for(int i=0;i+1<size();++i)(*this)[i]=1ll*(*this)[i+1]*(i+1)%mod;
        pop_back();
    }
    void itg()
    {
        push_back(0);
        for(int i=size()-1;i>0;--i)(*this)[i]=1ll*(*this)[i-1]*iinv[i]%mod;
        (*this)[0]=0;
    }
};
poly&operator+=(poly&a,const poly&b)
{
    if(a.size()<b.size())a.resize(b.size());
    for(int i=0;i<b.size();++i)add(a[i],b[i]);
    return a;
}
poly&operator-=(poly&a,const poly&b)
{
    if(a.size()<b.size())a.resize(b.size());
    for(int i=0;i<b.size();++i)add(a[i],mod-b[i]);
    return a;
}
poly operator+(const poly&a,const poly&b)
{
    poly c=a;c+=b;return c;
}
poly operator-(const poly&a,const poly&b)
{
    poly c=a;c-=b;return c;
}
poly operator*(const poly&a,const poly&b)
{
    if(!a.size()||!b.size())return {0};
    poly A=a,B=b,C;
    int len=getsz(a.size()+b.size()-1);
    A.resize(len),B.resize(len),C.resize(len);
    dft(A,len),dft(B,len);
    for(int i=0;i<len;++i)C[i]=1ll*A[i]*B[i]%mod;
    idft(C,len);
    return C;
}
poly operator*(int a,const poly&b)
{
    poly B=b;
    for(int i=0;i<B.size();++i)B[i]=1ll*B[i]*a%mod;
    return B;
}
poly operator*(const poly&b,int a)
{
    poly B=b;
    for(int i=0;i<B.size();++i)B[i]=1ll*B[i]*a%mod;
    return B;
}
poly drv(const poly&a)
{
    poly A=a;A.drv();return A;
}
poly itg(const poly&a)
{
    poly A=a;A.itg();return A;
}
poly modxn(const poly&a,int n)
{
    poly A;A.resize(n);for(int i=0;i<n&&i<a.size();++i)A[i]=a[i];return A;
}
poly inv(const poly&A,int n)
{
    assert(A[0]);
    int cur=1;
    poly b;b.resize(1);b[0]=pw(A[0],mod-2);
    while(cur<n)
    {
        cur<<=1;
        dft(b,cur*2);
        poly a=modxn(A,cur);
        dft(a,cur*2);
        for(int i=0;i<cur*2;++i)
            b[i]=(2*b[i]+1ll*(mod-a[i])*b[i]%mod*b[i])%mod;
        idft(b,cur*2);
        b.modxn(cur);
    }
    b.modxn(n);return b;
}
poly ln(const poly&a,int n)
{
    assert(a[0]==1);
    poly ret=a;ret.drv();
    ret=ret*inv(a,n-1);
    ret.modxn(n-1),ret.itg();
    return ret;
}
poly exp(const poly&a,int n)
{
    assert(a[0]==0);
    int cur=1;
    poly b;b.resize(1);b[0]=1;
    while(cur<n)
    {
        cur<<=1;
        b=b*(poly{1}-ln(b,cur)+modxn(a,cur));
        b.modxn(cur);
    }
    return modxn(b,n);
}
poly pow(const poly&a,int n,ll tim)
{
    if(a[0])
    {
        poly b=a*pw(a[0],mod-2);
        b=exp(ln(b,n)*(tim%mod),n);
        return b*pw(a[0],tim%(mod-1));
    }
    else assert(0);
}
poly pow_a0_may_be_0(const poly&a,int n,ll tim,bool big=0)
{
    if(a[0])return pow(a,n,tim);
    if(big)return poly(n,0);
    int pos=0;
    while(pos<a.size()&&!a[pos])++pos;
    if(pos==a.size())return poly(n,0);
    if((__int128)tim*pos>=n)return poly(n,0);
    poly b;b.resize(n-tim*pos);
    for(int i=0;i<b.size()&&i+pos<a.size();++i)
        b[i]=a[i+pos];
    b=pow(b,n,tim);b.resize(n);
    for(int i=n-1;i>=tim*pos;--i)b[i]=b[i-tim*pos];
    for(int i=tim*pos-1;i>=0;--i)b[i]=0;
    return b;
}
poly sqrt(const poly&a,int n)
{
    assert(a[0]==1);
    return exp(ln(a,n)*pw(2,mod-2),n);
}
}//namespace Poly
struct matrix
{
    int a[105][105];
    int det(int n)
    {
        int res=1;
        for(int i=1;i<=n;++i)
        {
            for(int j=i+1;j<=n;++j)if(j!=i)
            {
                while(a[i][i])
                {
                    int div=mod-a[j][i]/a[i][i];
                    for(int k=i;k<=n;++k)
                        a[j][k]=(a[j][k]+1ll*div*a[i][k])%mod;
                    swap(a[i],a[j]),res=mod-res;
                }
                swap(a[i],a[j]),res=mod-res;
            }
            res=1ll*res*a[i][i]%mod;
        }
        return res;
    }
}A;
int pw(int a,int b=mod-2)
{
    int c=1;
    for(;b;b>>=1,a=1ll*a*a%mod)
        if(b&1)c=1ll*c*a%mod;
    return c;
}
struct mint
{
    int a;
    mint(){a=0;}
    mint(int x){a=x%mod;}
    void operator+=(mint b){a+=b.a;if(a>=mod)a-=mod;}
    mint operator+(mint b)const{mint c=a;c+=b;return c;}
    void operator-=(mint b){a+=mod-b.a;if(a>=mod)a-=mod;}
    mint operator-(mint b)const{mint c=a;c-=b;return c;}
    void operator*=(mint b){a=1ll*a*b.a%mod;}
    mint operator*(mint b)const{mint c=a;c*=b;return c;}
    void operator/=(mint b){a=1ll*a*pw(b.a)%mod;}
    mint operator/(mint b)const{mint c=a;c/=b;return c;}
    mint operator-(){mint c=mod-a;if(c.a>=mod)c.a-=mod;return c;}
    bool operator==(mint b)const{return a==b.a;}
    bool operator!=(mint b)const{return a!=b.a;}
    bool operator<(mint b)const{return a<b.a;}
};
mint pw(mint a,int b)
{
    mint c=1;
    for(;b;b>>=1,a*=a)
        if(b&1)c*=a;
    return c;
}
namespace old
{
struct poly
{
    vector<mint>a;
    poly(){a.clear();}
    poly(mint x){a.resize(1);a[0]=x;}
    poly(vector<mint>x){a=x;}
    mint&operator[](int x){if(a.size()<=x)a.resize(x+1);return a[x];}
    int size()const{return a.size();}
    void resize(int x){a.resize(x);}
    void operator+=(poly b)
    {
        if(b.size()>a.size())a.resize(b.size());
        for(int i=0;i<b.size();++i)a[i]+=b[i];
    }
    poly operator+(poly b){poly c=*this;c+=b;return c;}
    void operator-=(poly b)
    {
        if(b.size()>a.size())a.resize(b.size());
        for(int i=0;i<b.size();++i)a[i]-=b[i];
    }
    poly operator-(poly b){poly c=*this;c-=b;return c;}
    poly operator*(poly b)
    {
        poly c;c.resize(a.size()+b.size()-1);
        for(int i=0;i<a.size();++i)
            for(int j=0;j<b.size();++j)
                c[i+j]+=a[i]*b[j];
        return c;
    }
    void operator*=(mint b)
    {
        for(auto&i:a)i*=b;
    }
    poly operator*(mint b){poly c=*this;c*=b;return c;}
    poly operator/(mint b){b=pw(b.a);return *this*b;}
    void operator/=(mint b){b=pw(b.a);*this*=b;}
    poly operator/(poly b)
    {
        poly a=*this;
        assert(b.size()==2);
        mint x=mint(1)/b[1];
        poly c;c.resize(a.size()-1);
        for(int i=a.size()-1;i;--i)
            c[i-1]=a[i]*x,a[i-1]-=c[i-1]*b[0];
        return c;
    }
    poly operator<<(int b)
    {
        poly c;c.resize(a.size()+b);
        for(int i=0;i<a.size();++i)c[i+b]=a[i];
        return c;
    }
    mint operator()(mint x)
    {
        mint cur=1,res=0;
        for(int i=0;i<a.size();++i)
            res+=cur*a[i],cur*=x;
        return res;
    }
};
struct point{mint x,y;point(mint a=0,mint b=0){x=a,y=b;}};
poly interpolate(const vector<point>&vec)
{
    poly all(mint(1)),sum;
    for(auto i:vec)
        all=all*poly({-i.x,mint(1)});
    for(auto i:vec)
    {
        mint den=1;
        for(auto j:vec)if(i.x!=j.x)den*=i.x-j.x;
        sum+=all/poly({-i.x,mint(1)})/den*i.y;
    }
    return sum;
}
}//namespace old
int C[1005][1005];
pair<int,int>wys[105][105];
int calc(int x,int y){if(x<0||y<0)return 0;return C[x+y][x];}
int main()
{
    Poly::init();
    for(int i=0;i<=1000;++i)
    {
        C[i][0]=1;
        for(int j=1;j<=i;++j)C[i][j]=(C[i-1][j]+C[i-1][j-1])%mod;
    }
    int n,m,k,r,c,v;scanf("%d%d%d%d%d%d",&n,&m,&k,&r,&c,&v);
    r+=v-1,c+=v-1;
    for(int i=1;i<k;++i)for(int j=1;j<k;++j)
    {
        int sx=n+i,sy=i,tx=j,ty=m+j;
        if(r>sx||c>ty){wys[i][j].first=calc(sx-tx,ty-sy);continue;}
        if(r<tx||c<sy){wys[i][j].second=calc(sx-tx,ty-sy);continue;}
        wys[i][j].second=(calc(sx-tx,ty-sy)+1ll*(mod-calc(sx-r,c-sy))*calc(r-tx,ty-c))%mod;
        for(int p=tx;p<r;++p)
        {
            int tmp=1ll*calc(sx-p,c-1-sy)*calc(p-tx,ty-c)%mod;
            add(wys[i][j].first,tmp),add(wys[i][j].second,mod-tmp);
        }
    }
    vector<old::point>vec;
    for(int i=1;i<=k;++i)
    {
        for(int x=1;x<k;++x)for(int y=1;y<k;++y)
            A.a[x][y]=(1ll*i*wys[x][y].first+wys[x][y].second)%mod;
        vec.push_back({i,A.det(k-1)});
    }
    old::poly res=old::interpolate(vec);
    printf("%d\n",res[v-1].a);
}