// u1s1 这个 Raney 引理一但想到就简单了。
// 每一项减 1，显然逐项和变为了 0，而且要求任何前缀和都 >= 0。
// 直接照搬 Raney 引理肯定是不行的。因为你无法构造合法的双射。开头补 1 无法回推。
// 考虑重新做一次证明。
// 我们把几何折线画出来，显然仅可从最低点出发。
// 问题是最低点有几个。
// ...
// 咱也没得做是吧。
// 还是考虑 Raney 引理。
// 咋整呢？
// 考虑把每个正数拆成若干个 1，开头补 1，然后只用暴力枚举某个数被拆开放到头尾的情况？
// 似乎也不行……
// 怎么办？
// 开头加 1 不行
// 末尾补一个 -1
// 然后就是后缀恒负
// 取反并翻转后就和 Raney 引理一样了。
// 于是即为 (m+1)!/(m+1)(m-n+1)=m!/(m-n+1) （最后这个相除是考虑 -1 的标号）

#include <algorithm>
#include <stdio.h>
#include <vector>
typedef long long llt;
typedef unsigned uint;typedef unsigned long long ullt;
typedef bool bol;typedef char chr;typedef void voi;
typedef double dbl;
template<typename T>bol _max(T&a,T b){return(a<b)?a=b,true:false;}
template<typename T>bol _min(T&a,T b){return(b<a)?a=b,true:false;}
template<typename T>T lowbit(T n){return n&-n;}
template<typename T>T gcd(T a,T b){return b?gcd(b,a%b):a;}
template<typename T>T lcm(T a,T b){return(a!=0||b!=0)?a/gcd(a,b)*b:(T)0;}
template<typename T>T exgcd(T a,T b,T&x,T&y){if(b!=0){T ans=exgcd(b,a%b,y,x);y-=a/b*x;return ans;}else return y=0,x=1,a;}
template<typename T>T power(T base,T index,T mod)
{
    T ans=1%mod;
    while(index)
    {
        if(index&1)ans=ans*base%mod;
        base=base*base%mod,index>>=1;
    }
    return ans;
}
namespace ConstMod
{
    template<const ullt p>
    class mod_ullt
    {
        private:
            ullt v;
            inline ullt chg(ullt w){return(w<p)?w:w-p;}
            inline mod_ullt _chg(ullt w){mod_ullt ans;ans.v=(w<p)?w:w-p;return ans;}
        public:
            mod_ullt():v(0){}
            mod_ullt(ullt v):v(v%p){}
            bol empty(){return!v;}
            inline ullt val(){return v;}
            friend bol operator<(mod_ullt a,mod_ullt b){return a.v<b.v;}
            friend bol operator>(mod_ullt a,mod_ullt b){return a.v>b.v;}
            friend bol operator<=(mod_ullt a,mod_ullt b){return a.v<=b.v;}
            friend bol operator>=(mod_ullt a,mod_ullt b){return a.v>=b.v;}
            friend bol operator==(mod_ullt a,mod_ullt b){return a.v==b.v;}
            friend bol operator!=(mod_ullt a,mod_ullt b){return a.v!=b.v;}
            inline friend mod_ullt operator+(mod_ullt a,mod_ullt b){return a._chg(a.v+b.v);}
            inline friend mod_ullt operator-(mod_ullt a,mod_ullt b){return a._chg(a.v+a.chg(p-b.v));}
            inline friend mod_ullt operator*(mod_ullt a,mod_ullt b){return a.v*b.v;}
            friend mod_ullt operator/(mod_ullt a,mod_ullt b){return b._power(p-2)*a.v;}
            friend mod_ullt operator^(mod_ullt a,ullt b){return a._power(b);}
            inline mod_ullt operator-(){return _chg(p-v);}
            mod_ullt sqrt()
            {
                if(power(v,(p-1)>>1,p)!=1)return 0;
                mod_ullt b=1;do b++;while(b._power((p-1)>>1)==1);
                ullt t=p-1,s=0,k=1;while(!(t&1))s++,t>>=1;
                mod_ullt x=_power((t+1)>>1),e=_power(t);
                while(k<s)
                {
                    if(e._power(1llu<<(s-k-1))!=1)x*=b._power((1llu<<(k-1))*t);
                    e=_power(p-2)*x*x,k++;
                }
                return _min(x,-x),x;
            }
            mod_ullt inv(){return _power(p-2);}
            mod_ullt _power(ullt index){mod_ullt ans(1),w(v);while(index){if(index&1)ans*=w;w*=w,index>>=1;}return ans;}
            voi read(){v=0;chr c;do c=getchar();while(c>'9'||c<'0');do v=(c-'0'+v*10)%p,c=getchar();while(c>='0'&&c<='9');v%=p;}
            voi print()
            {
                static chr C[20];uint tp=0;
                ullt w=v;do C[tp++]=w%10+'0',w/=10;while(w);
                while(tp--)putchar(C[tp]);
            }
            voi println(){print(),putchar('\n');}
            mod_ullt operator++(int){mod_ullt ans=*this;return v=chg(v+1),ans;}
        public:
            inline ullt&operator()(){return v;}
            inline mod_ullt&operator+=(mod_ullt b){return*this=_chg(v+b.v);}
            inline mod_ullt&operator-=(mod_ullt b){return*this=_chg(v+chg(p-b.v));}
            inline mod_ullt&operator*=(mod_ullt b){return*this=v*b.v;}
            mod_ullt&operator^=(ullt b){return*this=_power(b);}
            mod_ullt&operator/=(mod_ullt b){return*this=b._power(p-2)*v;}
            mod_ullt&operator++(){return v=chg(v+1),*this;}
    };
}
const ullt Mod=998244353;
typedef ConstMod::mod_ullt<Mod>modint;
int main()
{
#ifdef MYEE
    freopen("QAQ.in","r",stdin);
#endif
    modint ans(1);
    uint n,m=0;scanf("%u",&n);
    for(uint i=0,v;i<n;i++)scanf("%u",&v),m+=v;
    for(uint i=1;i<=m;i++)ans*=i;
    ans/=m-n+1;
    ans.println();
    return 0;
}

// Never Gonna Give You Up
// 明天你是否会想起 昨天未调完的题 明天你是否还惦记 考场写挂的暴力
// 集训队都已想不起 没能来雅礼的你 我也是偶然翻 OJ 才想起退役的你
// 谁羡慕比赛 AK 的你 谁膜拜红名的你 谁看了你的生涯回忆 谁借走你的 RP
// 你从前总是很小心 对拍后才肯交题 你也曾无意中说起 喜欢在深夜 AC
// 那时候比赛总很难 rating 总长得太慢 你总说退役遥遥无期 转眼就各分东西
// 谁秒了你出的模拟题 谁骂着毒瘤的你 谁看了你的题解笔记 谁传给学妹学弟
// 同行的日子都远去 我们也终会退役 多年后谁会再想起 定格考场的记忆
// 谁记得你出的模拟题 谁忘记毒瘤的你 谁学会你的题解笔记 谁教给学妹学弟