#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<long long> VL;
typedef vector<vector<long long>> VVL;
typedef pair<int,int> Pair;
typedef tuple<int,int,int> tpl;

#define ALL(a)  (a).begin(),(a).end()
#define SORT(c) sort((c).begin(),(c).end())
#define REVERSE(c) reverse((c).begin(),(c).end())
#define EXIST(m,v) (m).find((v)) != (m).end()
#define LB(a,x) lower_bound((a).begin(), (a).end(), x) - (a).begin()
#define UB(a,x) upper_bound((a).begin(), (a).end(), x) - (a).begin()

#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n)  FOR(i,0,n)
#define RFOR(i,a,b) for(int i=(a)-1;i>=(b);--i)
#define RREP(i,n) RFOR(i,n,0)

#define en "\n"

constexpr double EPS = 1e-9;
constexpr double PI  = 3.1415926535897932;
constexpr int INF = 2147483647;
constexpr long long LINF = 1LL<<60;
constexpr long long MOD = 998244353;

template<class T> inline bool chmax(T& a, T b){if(a<b){a=b;return true;}return false;}
template<class T> inline bool chmin(T& a, T b){if(a>b){a=b;return true;}return false;}

struct modint {
    long long x;
    modint(long long x=0):x((x%MOD+MOD)%MOD){}
    long long val(){
        return x;
    }
    modint operator-() const { return modint(-x);}
    modint& operator+=(const modint a) {
        if ((x += a.x) >= MOD) x -= MOD;
        return *this;
    }
    modint& operator-=(const modint a) {
        if ((x += MOD-a.x) >= MOD) x -= MOD;
    	return *this;
    }
    modint& operator*=(const modint a) {
    	(x *= a.x) %= MOD;
        return *this;
    }
    modint operator+(const modint a) const {
        modint res(*this);
        return res+=a;
    }
    modint operator-(const modint a) const {
        modint res(*this);
        return res-=a;
    }
    modint operator*(const modint a) const {
        modint res(*this);
        return res*=a;
    }
    modint pow(long long t) const {
        if (!t) return 1;
        modint a = pow(t>>1);
        a *= a;
    	if (t&1) a *= *this;
        return a;
    }

	// must be gcd(x,MOD)==1
    modint inv() const {
		// a^{-1} = 1/a MOD p (拡張Euclidの互除法)
		long long b = MOD, u = 1, v = 0, z = x;
		while(b){
			long long t = z / b;
			z -= t * b; swap(z, b);
			u -= t * v; swap(u, v);
		}
		u %= MOD;
		if (u < 0) u += MOD;
		return modint(u);
	}

    //modint inv() const {
    //    return pow(MOD-2);
    //}

    modint& operator/=(const modint a) {
    	return (*this) *= a.inv();
    }
    modint operator/(const modint a) const {
        modint res(*this);
        return res/=a;
    }
};
using mint = modint;

struct Factorial{

    vector<mint> fact, ifact;

    Factorial(int N): fact(N+1), ifact(N+1) {
        assert(N < MOD);

        fact[0] = 1;
        for(int i=0; i<N; i++) fact[i+1] = fact[i] * (i+1);

        ifact[N] = fact[N].inv();
        for(int i=N; i>0; i--) ifact[i-1] = ifact[i] * i;
    }

    mint C(int n, int k){
        if (k < 0 || k > n) return 0;
        return fact[n]*ifact[k]*ifact[n-k];
    }

    mint P(int n, int k){
        if (k < 0 || k > n) return 0;
        return fact[n]*ifact[n-k];
    }

    mint inv(int n){
        assert(n>0);
        return fact[n-1]*ifact[n];
    }
};

mint dp[101][101][10101];

void Main(){
    int N; cin >> N;
    int sum = 0;
    Factorial F(100);
    dp[0][0][0] = 1;
    REP(i,N){
        int w; cin >> w; sum += w;
        REP(j,i+1)REP(k,sum+1){
            dp[i+1][j+1][k+w] += dp[i][j][k];
            dp[i+1][j][k] += dp[i][j][k];
        }
    }
    if(sum&1){
        cout << 0 << en;
        return;
    }
    sum >>= 1;
    mint ans(0);
    REP(i,N+1){
        ans += dp[N][i][sum] * F.fact[i] * F.fact[N-i];
    }
    cout << ans.x << en;
    return;
}

int main(void){
    cin.tie(0);cout.tie(0);ios_base::sync_with_stdio(0);cout<<fixed<<setprecision(15);
    int t=1; //cin>>t;
    while(t--) Main();
    return 0;
}
/*
    Code written by Talant I.D.
*/
 
#include <bits/stdc++.h>
//~ #include <ext/pb_ds/assoc_container.hpp>
 
//~ using namespace __gnu_pbds;
using namespace std;
 
typedef long long ll;
typedef pair <int, int> pii;
typedef pair <ll, ll> pll;
//~ typedef tree <ll, null_type, less_equal <ll>, rb_tree_tag, tree_order_statistics_node_update> ordered_set;
 
#define precision(n) fixed << setprecision(n)
#define pb push_back
#define ub upper_bound
#define lb lower_bound
#define mp make_pair
#define eps (double)1e-9
#define PI 2*acos(0.0)
#define endl "\n"
#define sz(v) int((v).size())
#define all(v) v.begin(),v.end()
#define rall(v) v.rbegin(),v.rend()
#define do_not_disturb ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
#define OK cout << "OK" << endl;
 
const int mod = 998244353;
 
ll mode(ll a) {
    while (a < 0) {
        a += mod;
    }
    return a % mod;
}
 
ll subt(ll a, ll b) {
    return mode(mode(a)-mode(b));
}
 
ll add(ll a, ll b) {
    return mode(mode(a)+mode(b));
}
 
ll mult(ll a, ll b) {
    return mode(mode(a)*mode(b));
}
 
ll binpow(ll a, ll b) {
    ll res = 1;
    while (b) {
        if (b&1) res = mult(res, a);
        a = mult(a, a);
        b >>= 1;
    }
    return res;
}

ll dp[10003][103];
ll fact[10003];

int main() {
    do_not_disturb
    
    fact[0] = fact[1] = 1;
    for (ll i = 2; i < 10003; i++) {
        fact[i] = mult(fact[i-1], i);
    }
    dp[0][0] = 1;
    
    int n;
    cin >> n;
    vector <int> a(n);
    for (auto &to : a) cin >> to;
    
    for (auto to : a) {
        for (int i = 5000; i >= to; i--) {
            for (int j = 0; j < 100; j++) {
                dp[i][j+1] = add(dp[i][j+1], dp[i-to][j]);
            }
        }
    }
    
    ll ans = 0;
    ll sum = 0;
    for (auto to : a) sum += to;
    if (sum&1) {
        cout << 0;
        return 0;
    }
    sum /= 2;
    
    for (int i = 0; i <= 100; i++) {
        ans = add(ans, mult(dp[sum][i], mult(fact[i], fact[n-i])));
    }
    
    cout << ans;
    
    return 0;
}
