#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

const ll modi = 998244353;

ll modExp(ll base,ll times){
    ll ans = 1;
    while (times){
        if (times & 1) ans = ans * base % modi;
        base = base * base % modi;
        times >>= 1;
    }
    return ans;
}

ll inv(ll x){
    return modExp(x,modi-2);
}

namespace NTT{
    vector<ll> roots = {0,1};
    vector<int> bit_reverse;
    int max_size = -1;
    ll root;
    bool is_power_of_two(int n){
        return (n & (n-1)) == 0;
    }
    int round_up_power_two(int n){
        while (n & (n-1)){
            n = (n | (n-1))+1;
        }
        return max(n,1);
    }
    int get_length(int n){
        assert(is_power_of_two(n));
        return __builtin_ctz(n);
    }
    void bit_reorder(int n,vector<ll> & values){
        if ((int) bit_reverse.size() != n){
            bit_reverse.assign(n,0);
            int length = get_length(n);
            for (int i = 0;i < n;i++){
                bit_reverse[i] = (bit_reverse[i >> 1] >> 1) + ((i & 1) << (length - 1));
            }
        }
        for (int i = 0;i < n;i++){
            if (i < bit_reverse[i]){
                swap(values[i], values[bit_reverse[i]]);
            }
        }
    }
    void find_root(){
        max_size = 1 << __builtin_ctz(modi-1);
        root = 2;
        while (!(modExp(root,max_size) == 1 && modExp(root, max_size/2) != 1)) root++;
    }
    void prepare_roots(int n){
        if (max_size < 0) find_root();
        assert (n <= max_size);
        if ((int)roots.size() >= n) return;
        int length = get_length(roots.size());
        roots.resize(n);
        while (1 << length < n){
            ll z = modExp(root,max_size >> (length+1));
            for (int i = 1 << (length - 1); i < 1 << length;i++){
                roots[2*i] = roots[i];
                roots[2*i+1] = (roots[i] * z) % modi;
            }
            length++;
        }
    }
    void fft_iterative(int N,vector<ll> & values){
        assert(is_power_of_two(N));
        prepare_roots(N);
        bit_reorder(N, values);
        for (int n = 1;n < N;n *= 2){
            for (int start = 0; start < N;start += 2*n){
                for (int i = 0;i < n;i++){
                    ll even = values[start+i];
                    ll odd = values[start+n+i] * roots[n+i];
                    odd %= modi;
                    values[start+n+i] = even-odd+modi;
                    values[start+i] = even+odd;
                    values[start+n+i] %= modi;
                    values[start+i] %= modi;
                }
            }
        }
    }
    const int FFT_CUTOFF = 150;
    vector<ll> mod_multiply(vector<ll> left,vector<ll> right){
        int n = left.size();
        int m = right.size();
        if (min(n,m) < FFT_CUTOFF){
            const uint64_t ULL_BOUND = numeric_limits<uint64_t>::max() - (uint64_t) modi*modi;
            vector<uint64_t> result(n+m-1,0);
            for (int i = 0;i < n;i++){
                for (int j = 0;j < m;j++){
                    result[i+j] += (uint64_t)((int)left[i])*((int)right[j]);
                    if (result[i+j] > ULL_BOUND) result[i+j] %= modi;
                }
            }
            for (uint64_t & x: result){
                if (x >= modi) x %= modi;
            }
            return vector<ll>(result.begin(),result.end());
        }
        int N = round_up_power_two(n+m-1);
        left.resize(N);
        right.resize(N);
        bool equal = left == right;
        fft_iterative(N,left);
        if (equal) right = left;
        else fft_iterative(N,right);
        ll inv_N = inv(N);
        for (int i = 0;i < N;i++){
            left[i] *= (right[i] * inv_N) % modi;
            left[i] %= modi;
        }
        reverse(left.begin()+1,left.end());
        fft_iterative(N,left);
        left.resize(n+m-1);
        return left;
    }
    vector<ll> mod_power(const vector<ll> & v,int exponent){
        assert(exponent>=0);
        vector<ll> result = {1};
        if (exponent == 0) return result;
        for (int k = 31 - __builtin_clz(exponent);k >= 0;k--){
            result = mod_multiply(result,result);
            if (exponent >> k & 1){
                result = mod_multiply(result,v);
            }
        }
        return result;
    }
}


int main(){
    int x1,x2,x3;
    int k;
    ll p;
    cin >> x1 >> x2 >> x3 >> k >> p;
    vector<ll> poly = {1,1,1};
    vector<ll> ret = NTT::mod_power(poly, k);
    ll e = 0;

    ll delta = x1-x2;
    for (int i = 0;i <= 2*k;i++){
        ll new_delta = delta + i - k;
        e = (e + abs(new_delta) * ret[i]) % modi;
    }
    delta = x1-x3;
    for (int i = 0;i <= 2*k;i++){
        ll new_delta = delta + i - k;
        e = (e + abs(new_delta) * ret[i]) % modi;
    }
    delta = x2-x3;
    for (int i = 0;i <= 2*k;i++){
        ll new_delta = delta + i - k;
        e = (e + abs(new_delta) * ret[i]) % modi;
    }
    cout << e * inv(modExp(3,k)) % modi * inv(2) % modi << endl;
}