//include
//------------------------------------------
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>

#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>

#include <stdexcept>

using namespace std;

//conversion
//------------------------------------------
inline int toint(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class t> inline string tostring(t x) { ostringstream sout; sout << x; return sout.str(); }

//debug
#define dump(x)  cerr << #x << " = " << (x) << endl
#define debug(x) cerr << #x << " = " << (x) << " (l" << __line__ << ")" << " " << __file__ << endl

// type alias
using ll = long long;
using ull = unsigned long long;

// constant value
const ll mod = 1000000007ll;

template<class ll>
inline ll getCeilExponent(ll a)
{
	if (a <= 0)
	{
		throw invalid_argument("vaule equal to or less than 0 should not be valid");
	}

	ll index = 0;
	--a;
	for (; a != 0; a >>= 1)
	{
		++index;
	}
	return index;
}

template<class ll>
inline ll getFloorExponent(ll a)
{
	if (a <= 0)
	{
		throw invalid_argument("vaule equal to or less than 0 should not be valid");
	}

	ll index = 0;
	a >>= 1;
	for (; a != 0; a >>= 1)
	{
		++index;
	}
	return index;
}

// computational complexity: o(log(max(a, b))) 
template<class ll>
inline ll getGcd(ll a, ll b)
{
	if (b == 0)
	{
		return a;
	}
	return getGcd(b, a % b);
}

// computational complexity: o(log(max(a, b))) 
template<class ll>
inline pair<ll, ll> getBezoutsIdentitySolution(ll a, ll b)
{
	if (b == 0)
	{
		return { 1, 0 };
	}
	auto sol = getBezoutsIdentitySolution(b, a % b);
	return { sol.second, sol.first - (a / b) * sol.second };
}

inline ll getModValue(ll a, ll m)
{
	return (a % m + m) % m;
}

// computational complexity: o(log(max(a, n))) 
inline ll getModInverse(ll a, ll m)
{
	auto sol = getBezoutsIdentitySolution(a, m);
	if (a * sol.first + m * sol.second != 1)
	{
		return -1;
	}
	return getModValue(sol.first, m);
}

ll getModCombinatorialNumber(ll n, ll r, ll m)
{
	ll res = 1;
	for (; n > 0; --n, --r)
	{
		res = (((res * n) % m) * getModInverse(n, m)) % m;
	}
	return getModValue(res, m);
}

ll getModPower(ll base, unsigned t, ll m)
{
	if (t == 0)
	{
		return 1ll;
	}

	auto res = getModPower(base, t >> 1, m);
	res = getModValue(res * res, m);
	if (t % 2 == 1)
	{
		res = getModValue(res * base, m);
	}
	return res;
}

ll MOD = 998244353LL;

ll dps(ll i, ll minLength, vector<vector<ll>>& combs, const vector<ll>& as)
{
	if (combs[i][minLength] != -1LL)
	{
		return combs[i][minLength];
	}

	combs[i][minLength] = getModValue(
		dps(i + 1, max(minLength - as[i], 0LL), combs, as) + 
		getModValue(
			2LL * dps(i + 1, minLength, combs, as),
			MOD
		),
	MOD);

	return combs[i][minLength];
}

ll dps2(ll i, ll minLength, vector<vector<ll>>& combs2, const vector<ll>& as)
{
	if (combs2[i][minLength] != -1LL)
	{
		return combs2[i][minLength];
	}

	ll res = 0LL;
	if (minLength >= as[i])
	{
		res = dps2(i + 1, max(minLength - as[i], 0LL), combs2, as);
	}

	res = getModValue(res + dps2(i + 1, minLength, combs2, as), MOD);
	combs2[i][minLength] = res;

	return combs2[i][minLength];
}

int main()
{
	cin.tie(0);
	ios::sync_with_stdio(false);

	ll N;
	cin >> N;

	vector<ll> as(N);
	ll sum = 0;
	for (ll i = 0; i < N; ++i)
	{
		cin >> as[i];
		sum += as[i];
	}

	ll halfSum = static_cast<ll>(ceil(static_cast<double>(sum) / 2.0));
	vector<vector<ll>> combs(N + 1, vector<ll>(halfSum + 1LL, -1LL));
	combs[N][0] = 1LL;
	for (ll i = 1; i < halfSum + 1LL; ++i)
	{
		combs[N][i] = 0LL;
	}
	ll res = dps(0LL, halfSum, combs, as);

	vector<vector<ll>> combs2(N + 1, vector<ll>(halfSum + 1LL, -1LL));
	combs2[N][0] = 1LL;
	for (ll i = 1; i <  halfSum + 1LL; ++i)
	{
		combs2[N][i] = 0LL;
	}
	ll res2 = (halfSum * 2LL == sum ? dps2(0LL, halfSum, combs2, as) : 0LL);
	
	ll fin = getModValue(
		getModValue(
			getModPower(3LL, N, MOD) - getModValue(res * 3, MOD),
		MOD) +
		getModValue(res2 * 3, MOD),
	MOD);

	cout << fin << endl;

	return 0;
}

Measured memory_bytes: 212128