#include<bits/stdc++.h>
#define ff first
#define ss second
#define pb push_back
typedef long long ll;
using namespace std;
typedef pair<int,int> pii;

const int mod=998244353;
inline int add(int x,int y){int ret=x+y;if(ret>=mod)ret-=mod;return ret;}
inline int sub(int x,int y){int ret=x-y;if(ret<0)ret+=mod;return ret;}
inline int mul(int x,int y){return ((ll)x*y)%mod;}
inline int step(int base,int pw){int ret=1;while(pw){if(pw&1)ret=mul(ret,base);base=mul(base,base);pw>>=1;}return ret;}
inline int invv(int x){return step(x,mod-2);}

namespace polynomial{

    const int maxn=(1<<20);
    int proot=step(3,7*17*8);
    int prekw[maxn];
    int prekinv[maxn];
    int INF=1e9;
    bool prek_flag=0;
    void prek(){

        if(prek_flag)return;
        prek_flag=1;

        prekw[0]=1;
        for(int i=1;i<maxn;i++)
            prekw[i]=mul(prekw[i-1],proot);


        prekinv[0]=1;
        for(int i=1;i<maxn;i++)prekinv[i]=mul(prekinv[i-1],i);

        int curr=invv(prekinv[maxn-1]);
        for(int i=maxn-1;i>0;i--){
            prekinv[i]=mul(curr,prekinv[i-1]);
            curr=mul(curr,i);
        }

    }
    const int MAGIC=500;

    struct polyn{

        vector<int>a;

        polyn(){}
        polyn(vector<int>b){a=b;}

        void push_back(int x){
            a.pb(x);
        }
        int size(){return a.size();}
        void resize(int n){a.resize(n);}

        int& operator [](int x){
            if(x>=a.size())a.resize(x+1);
            return a[x];
        }

        polyn operator -(polyn b){
            polyn ret;
            ret.resize(max(b.size(),(int)a.size()));
            for(int i=0;i<a.size();i++)ret[i]=add(ret[i],a[i]);
            for(int i=0;i<b.size();i++)ret[i]=sub(ret[i],b[i]);
            return ret;
        }

        polyn operator +(polyn b){
            polyn ret;
            ret.resize(max(b.size(),(int)a.size()));
            for(int i=0;i<a.size();i++)ret[i]=add(ret[i],a[i]);
            for(int i=0;i<b.size();i++)ret[i]=add(ret[i],b[i]);
            return ret;
        }

        polyn operator *(int c){
            polyn ret=(*this);
            for(int i=0;i<ret.size();i++)ret[i]=mul(ret[i],c);
            return ret;
        }

        friend polyn operator *(const int c,polyn p){
            return p*c;
        }


        void fft(vector<int>&a,bool invert){

            prek();

            int n=a.size();
            int j=0;
            for(int i=1;i<n;i++){
                int bit=n>>1;
                for(;bit&j;bit>>=1)j^=bit;
                j^=bit;
                if(i<j)swap(a[i],a[j]);
            }

            for(int len=2;len<=n;len<<=1){
                int hlen=len/2;
                for(int i=0;i<n;i+=len){
                    int curr=0;
                    int d=maxn/len;
                    if(invert)d=maxn-d;
                    for(int j=0;j<hlen;j++){
                        int pom1=a[i+j];
                        int pom2=mul(a[i+j+hlen],prekw[curr]);
                        a[i+j]=add(pom1,pom2);
                        a[i+j+hlen]=sub(pom1,pom2);
                        curr+=d;
                        if(curr>=maxn)curr-=maxn;
                    }
                }
            }

            if(invert){
                int invn=invv(n);
                for(int i=0;i<n;i++)a[i]=mul(a[i],invn);
            }

        }

        polyn brute_pmul(polyn b){
            polyn ret;
            ret.resize(a.size()+b.size()-1);
            for(int i=0;i<a.size();i++)
                for(int j=0;j<b.size();j++)
                    ret[i+j]=add(ret[i+j],mul(a[i],b[j]));
            return ret;
        }

        polyn operator *(polyn b){

            int n=1;
            while(n<(int)a.size()+(int)b.size()-1)n<<=1;
            vector<int>ret=a;

            if(min((int)a.size(),b.size())<MAGIC)return brute_pmul(b);

            ret.resize(n);
            b.resize(n);

            fft(ret,0);
            fft(b.a,0);
            for(int i=0;i<n;i++)ret[i]=mul(ret[i],b[i]);
            fft(ret,1);
            return ret;
        }

        polyn mod_xk(int n){
            polyn ret(a);
            ret.resize(n);
            return ret;
        }

        polyn mul_xk(int n){

            polyn ret=(*this);

            int pom=ret.size();
            ret.resize(ret.size()+n);

            for(int i=ret.size()-1;i>=n;i--)ret[i]=ret[i-n];
            for(int i=0;i<n;i++)ret[i]=0;
            return ret;
        }

        polyn inv(int n){

            polyn bk;
            assert(a[0]!=0);
            bk.pb(invv(a[0]));
            int sz=1;
            while(sz<n){
                sz<<=1;
                polyn pom=((*this).mod_xk(sz)*bk).mod_xk(sz);
                for(int i=0;i<pom.size();i++)pom[i]=sub(0,pom[i]);
                pom[0]=add(pom[0],2);
                bk=(bk*pom).mod_xk(sz);
            }
            return bk.mod_xk(n);
        }

        void reduce(){
            while(a.size() && a.back()==0)a.pop_back();
        }

        polyn reverse(){
            polyn ret(a);
            std::reverse(ret.a.begin(),ret.a.end());
            return ret;
        }

        polyn operator %(polyn b){

            b.reduce();
            reduce();

            int n=a.size();
            int m=b.size();
            if(n<m){
                return (*this);
            }

            polyn p=(reverse()*b.reverse().inv(n-m+1)).mod_xk(n-m+1).reverse();

            return (*this)-p*b;
        }

        polyn operator /(polyn b){

            b.reduce();
            reduce();

            int n=a.size();
            int m=b.size();
            if(n<m){
                polyn ret;
                return ret;
            }

            polyn p=(reverse()*b.reverse().inv(n-m+1)).mod_xk(n-m+1).reverse();
            return p;
        }


        void build_multipoint_eval_tree(int x,int l,int r,vector<polyn>&tree,vector<int>&xp){
            if(l==r){
                tree[x].pb(sub(0,xp[l]));
                tree[x].pb(1);
                return;
            }
            int mid=(l+r)/2;
            build_multipoint_eval_tree(x*2,l,mid,tree,xp);
            build_multipoint_eval_tree(x*2+1,mid+1,r,tree,xp);
            tree[x]=tree[x*2]*tree[x*2+1];
        }
        void multipoint_evaluate_tree(int x,int l,int r,vector<polyn>&tree,vector<int>&ret,polyn p){
            p=p%tree[x];
            if(l==r){
                ret.pb(p[0]);
                return;
            }
            int mid=(l+r)/2;
            multipoint_evaluate_tree(x*2,l,mid,tree,ret,p);
            multipoint_evaluate_tree(x*2+1,mid+1,r,tree,ret,p);
        }
        vector<int> multipoint_eval(vector<int>x){

            vector<polyn>tree(4*x.size()+10);
            build_multipoint_eval_tree(1,0,x.size()-1,tree,x);
            vector<int>ret;
            multipoint_evaluate_tree(1,0,x.size()-1,tree,ret,(*this));

            return ret;
        }

        polyn integral(){

            polyn ret=(*this);

            prek();

            ret.a.resize(a.size()+1);
            for(int i=ret.a.size()-2;i>=0;i--){
                ret.a[i+1]=mul(ret.a[i],prekinv[i+1]);
            }
            ret.a[0]=0;

            return ret;
        }

        polyn deriv(){

            polyn ret=(*this);

            for(int i=0;i<ret.a.size()-1;i++){
                ret.a[i]=mul(i+1,ret.a[i+1]);
            }
            ret.a.pop_back();

            return ret;
        }

        polyn log(int n){
            assert(a[0]==1);
            return (deriv().mod_xk(n)*inv(n)).mod_xk(n).integral().mod_xk(n);
        }

        polyn exp(int n){

            assert(a[0]==0);

            int sz=1;
            polyn bk;
            bk[0]=1;

            while(sz<n){
                sz<<=1;
                polyn pom=mod_xk(sz)-bk.log(sz);
                pom[0]=add(pom[0],1);
                bk=(bk*pom).mod_xk(sz);
            }

            return bk.mod_xk(n);

        }

        polyn shift_left(int x){
            polyn ret=(*this);
            for(int i=0;i+x<ret.size();i++)ret[i]=ret[i+x];
            ret.resize(ret.size()-x);
            return ret;
        }


        void ispis(){
            for(int i=0;i<a.size();i++)printf("%d ",a[i]);
            printf("POLYN ispis\n");
        }

    };

}

using namespace polynomial;

const int maxnr=410;

int fact[maxnr],inv[maxnr];
int nCk(int n,int k){
    if(k<0 || n<0 || n<k)return 0;
    return mul(fact[n],mul(inv[k],inv[n-k]));
}
void prek_fact(){
    fact[0]=1;
    for(int i=1;i<maxnr;i++)fact[i]=mul(fact[i-1],i);
    inv[maxnr-1]=invv(fact[maxnr-1]);
    for(int i=maxnr-1;i>0;i--)inv[i-1]=mul(inv[i],i);
}

polyn connected_graphs;
void prek_connected_graphs(){

    polyn h;

    for(int n=0;n<maxnr;n++){
        h[n]=mul(step(2,(n*(n-1))/2),inv[n]);
       ///printf("%d ",h[n]);
    }

    connected_graphs=h.log(maxnr);
    for(int i=0;i<maxnr;i++)connected_graphs[i]=mul(connected_graphs[i],fact[i]);
}

int dp_k_bridges_aux[maxnr][maxnr];
int zero_bridges[maxnr];
void prek_k_bridges(){

    dp_k_bridges_aux[0][0]=1;
    dp_k_bridges_aux[1][1]=1;
    zero_bridges[1]=1;
    for(int n=2;n<maxnr;n++){

        for(int k=2;k<maxnr;k++){

            for(int i=1;i<=n;i++){

                int pom=mul(nCk(n,i),mul(i, mul(dp_k_bridges_aux[n-i][k-1],zero_bridges[i] ) ) );
                dp_k_bridges_aux[n][k]=add(dp_k_bridges_aux[n][k], pom);

                //printf("%d %d | %d | %d %d %d %d  SPECIAL\n",n,k,pom,i,nCk(n,i),dp_k_bridges_aux[n-i][k-1],zero_bridges[i]);

            }

            dp_k_bridges_aux[n][k]=mul(dp_k_bridges_aux[n][k],invv(k));

        }

        int pom=connected_graphs[n];
        //printf("%d %d FULL\n",n,pom);
        for(int i=2;i<maxnr;i++){
            pom=sub(pom, mul(dp_k_bridges_aux[n][i],step(n,i-2) ) );
            //printf("%d %d | %d op\n",n,i,mul(dp_k_bridges_aux[n][i],step(n,i-2) ));
        }

        zero_bridges[n]=pom;
        dp_k_bridges_aux[n][1]=mul(pom,n);

    }

    /*for(int i=1;i<maxnr;i++){
        printf("%d %d\n",i,zero_bridges[i]);
    }*/

}
int dp[maxnr][maxnr];
void prek_k_comps(){

    dp[0][0]=1;
    for(int k=1;k<maxnr;k++){
        for(int n=1;n<maxnr;n++){

            for(int i=1;i<=n;i++){

                int pom=mul(nCk(n-k,i-1),mul(i, mul(dp[n-i][k-1],zero_bridges[i] ) ) );
                dp[n][k]=add(dp[n][k], pom);

                ///printf("%d %d | %d | %d %d %d %d  SPECIAL\n",n,k,pom,i,nCk(n-k,i-1),dp[n-i][k-1],zero_bridges[i]);

            }

        }

       // printf("%d AA\n",k);
    }
    //printf("doso\n");

    for(int n=1;n<maxnr;n++){
        for(int k=1;k<=maxnr;k++){
            if(k==1)dp[n][k]=mul(dp[n][k],invv(n));
            else dp[n][k]=mul(dp[n][k],step(n,k-2));
        }
    }

    //printf("doso\n");
}

int main(){

    ///freopen("test.txt","r",stdin);

    prek_fact();
    prek_connected_graphs();
    //cout<<"opa"<<endl;
    prek_k_bridges();
    //cout<<"opa"<<endl;
    prek_k_comps();
   // cout<<"opa"<<endl;

    int n;
    scanf("%d",&n);
    vector<int>dp2[2];
    dp2[0].resize(n+1);dp2[1].resize(n+1);
    int curr=0;
    dp2[0][0]=1;
    for(int i=1;i<=n;i++){
        int a;
        scanf("%d",&a);

        int nxt=(curr^1);
        for(int j=0;j<=n;j++)dp2[nxt][j]=0;
        for(int j=0;j<=n;j++){
            if(j>0)dp2[nxt][j]=mul(dp2[curr][j-1],a);
            dp2[nxt][j]=add(dp2[nxt][j],dp2[curr][j]);
        }

        curr=nxt;
    }

    int rez=0;
    for(int i=1;i<=n;i++){
        ///printf("%d | %d %d \n",i,dp2[curr][i],dp[n][i]);
        rez=add(rez,mul(dp2[curr][i],dp[n][i]));
    }
    printf("%d\n",rez);

    return 0;
}