#include<bits/stdc++.h>

using namespace std;
using ll=long long;

template<const int mod>
struct modint{
    int64_t a;

    public:
        // 初期化
        modint (): a(0){}
        modint (int64_t a): a((a%mod+mod)%mod) {}

        // マイナス元
        modint operator-() const { return modint(-a);}

        // 加法
        modint& operator+=(const modint &y){
            if ((a+=y.a)>=mod) a-=mod;
            return *this;
        }

        modint operator+(const modint &y) const { return modint(*this)+=y;}
        modint& operator+=(const int64_t &b) { return (*this)+=modint<mod>(b);}
        modint operator+(const int64_t b) const { return modint(*this)+=b;}

        // 減法
        modint& operator-=(const modint &y){
            if ((a+=mod-y.a)>=mod) a-=mod;
            return *this;
        }

        modint operator-(const modint &y) const { return modint(*this)-=y;}
        modint& operator-=(const int64_t &b) { return (*this)-=modint<mod>(b);}
        modint operator-(const int64_t b) const { return modint(*this)-=b;}

        // 乗法
        modint& operator*=(const modint &y){
            (a*=y.a)%=mod;
            return *this;
        }

        modint operator*(const modint &y) const { return modint(*this)*=y;}
        modint& operator*=(const int64_t &b) {return (*this)*=modint<mod>(b);}
        modint operator*(const int64_t b) const { return modint(*this)*=b;}

        // 除法
        modint& operator/=(const modint &y){
            return (*this)*=y.inverse();
        }

        modint operator/(const modint &y) const { return modint(*this)/=y;}
        modint& operator/=(const int64_t &b) { return (*this)/=modint<mod>(b);}
        modint operator/(const int64_t b) const { return modint(*this)/=b;}

        // モジュラー逆元
        modint inverse() const{
            int64_t s=1,t=0,u;
            int64_t x=a,y=mod;
            while (y){
                auto q=x/y,r=x%y;
                x=y; y=r;
                u=s-q*t;
                s=t; t=u;
            }
            assert(x==1);

            modint res(s);
            return res;
        }

        // 比較
        bool operator==(const modint &y) const { return (a==y.a);}
        bool operator==(const int64_t &b) const { return ((a-b)%mod==0);}

        bool operator!=(const modint &y) const { return !(a==y);}
        bool operator!=(const int64_t &b) const { return !(a==b);}

        // 入力
        friend istream &operator>>(istream &is, modint &x) {is >> x.a; return (is);}

        // 出力
        friend ostream &operator<<(ostream &os, const modint &x) { return os << x.a;}
};

template<const int mod>
modint<mod> operator+(const int64_t &a, const modint<mod> x){
    return modint<mod>((a%mod)+x.a);
}

template<const int mod>
modint<mod> operator-(const int64_t &a, const modint<mod> x){
    return modint<mod>((a%mod)-x.a);
}
template<const int mod>
modint<mod> operator*(const int64_t &a, const modint<mod> x){
    return modint<mod>((a%mod)*x.a);
}

using modint998244353=modint<998244353>;

modint998244353 solve(ll L, ll R, ll A, ll B, ll C){
    ll C2=max(0LL,C-A-B), D=R+1-(L+A+B+C2);

    if (D<0) {return modint998244353();}

    modint998244353 c2(C2), d(D);
    return d*(d+1)*(3*c2+d+2)/6;
}

int main(){
    ll L,R,A,B,C;
    cin >> L >> R >> A >> B >> C;
    cout << solve(L,R,A,B,C) << endl;
}