#include <bits/stdc++.h>

using namespace std;

typedef long long ll;

template<int mod>
class Modular {
public:
    int val;
    Modular() : val(0) {}
    Modular(int new_val) : val(new_val) {}
    // Modular(long long new_val) : val(new_val % mod) {}  // AFFECTS OPERATOR* (because it has one more %)
    friend Modular operator+(const Modular& a, const Modular& b) {
        if (a.val + b.val >= mod) return a.val + b.val - mod;
        else return a.val + b.val;
    }
    friend Modular operator-(const Modular& a, const Modular& b) {
        if (a.val - b.val < 0) return a.val - b.val + mod;
        else return a.val - b.val;
    }
    friend Modular operator*(const Modular& a, const Modular& b) {
        return 1ll * a.val * b.val % mod;
    }
    friend Modular binpow(Modular a, long long n) {
        Modular res = 1;
        for (; n; n >>= 1) {
            if (n & 1) res *= a;
            a *= a;
        }
        return res;
    }
    /* ALTERNATIVE INVERSE FUNCTION USING EXTENDED EUCLIDEAN ALGORITHM
    friend void gcd(int a, int b, Modular& x, Modular& y) {
        if (a == 0) {
            x = Modular(0);
            y = Modular(1);
            return;
        }
        Modular x1, y1;
        gcd(b % a, a, x1, y1);
        x = y1 - (b / a) * x1;
        y = x1;
    }
    friend Modular inv(const Modular& a) {
        Modular x, y;
        gcd(a.val, mod, x, y);
        return x;
    }
    */
    friend Modular inv(const Modular& a) {
        return binpow(a, mod - 2);
    }
    Modular operator/(const Modular& ot) const {
        return *this * inv(ot);
    }
    Modular& operator++() {
        if (val + 1 == mod) val = 0;
        else ++val;
        return *this;
    }
    Modular operator++(int) {
        Modular tmp = *this;
        ++(*this);
        return tmp;
    }
    Modular operator+() const {
        return *this;
    }
    Modular operator-() const {
        return 0 - *this;
    }
    Modular& operator+=(const Modular& ot) {
        return *this = *this + ot;
    }
    Modular& operator-=(const Modular& ot) {
        return *this = *this - ot;
    }
    Modular& operator*=(const Modular& ot) {
        return *this = *this * ot;
    }
    Modular& operator/=(const Modular& ot) {
        return *this = *this / ot;
    }
    bool operator==(const Modular& ot) const {
        return val == ot.val;
    }
    bool operator!=(const Modular& ot) const {
        return val != ot.val;
    }
    bool operator<(const Modular& ot) const {
        return val < ot.val;
    }
    bool operator>(const Modular& ot) const {
        return val > ot.val;
    }
    explicit operator int() const {
        return val;
    }
};

template<int mod>
istream& operator>>(istream& istr, Modular<mod>& x) {
    return istr >> x.val;
}

template<int mod>
ostream& operator<<(ostream& ostr, const Modular<mod>& x) {
    return ostr << x.val;
}

const int mod = 998244353; // 998244353
using Mint = Modular<mod>;

const int N = 500 + 10;
int a[N];
int b[N];
Mint dp[N][N];
Mint pref[N];

Mint solve(int n) {
    int m = 0;
    for (int i = 1; i <= n; i++) {
        for (int k = 1; k <= a[i]; k++) {
            b[++m] = i;
        }
    }
    for (int i = 0; i <= m; i++) {
        for (int j = 0; j <= m; j++) {
            dp[i][j] = 0;
        }
    }
    for (int i = 1; i <= m; i++) {
        if (b[i] > b[i - 1]) {
            dp[i][i - 1]++;
        }
//        for (int j = 0; j <= i - 1; j++) {
//            for (int k = i + 1; k <= m; k++) {
//                if (k == i + 1 || b[k] > b[k - 1]) {
//                    for (int x = 0; x <= j; x++) {
//                        dp[k][j - x + k - i - 1] += dp[i][j];
//                    }
//                }
//            }
//        }
        pref[0] = dp[i][0];
        for (int j = 1; j <= i - 1; j++) {
            pref[j] = pref[j - 1] + dp[i][j];
        }
        for (int k = i + 1; k <= m; k++) {
            if (k == i + 1 || b[k] > b[k - 1]) {
                for (int y = 0; y <= i - 1; y++) {
                    dp[k][y + k - i - 1] += pref[i - 1] - (y == 0 ? 0 : pref[y - 1]);
                }
            }
        }
    }

//    for (int i = 1; i <= m; i++) {
//        for (int j = 0; j <= i - 1; j++) {
//            cout << dp[i][j] << " ";
//        }
//        cout << "\n";
//    }

    Mint ans = 0;
    for (int j = 0; j <= m; j++) {
        ans += dp[m][j];
    }
    return ans;
}

Mint slow(int n) {
    int m = 0;
    for (int i = 1; i <= n; i++) {
        for (int k = 1; k <= a[i]; k++) {
            b[++m] = i;
        }
    }
    vector<int> pref_max(m + 1), suf_min(m + 1);
    Mint res = 0;
    do {
        bool ok = true;
        pref_max[1] = b[1];
        for (int i = 2; i <= m; i++) {
            pref_max[i] = max(pref_max[i - 1], b[i]);
        }
        suf_min[m] = b[m];
        for (int i = m - 1; i >= 1; i--) {
            suf_min[i] = min(suf_min[i + 1], b[i]);
        }
        for (int i = 2; i <= m - 1; i++) {
            if (pref_max[i - 1] > b[i] && b[i] > suf_min[i + 1]) {
                ok = false;
            }
        }
        res += ok;
    } while (next_permutation(b + 1, b + m + 1));
    return res;
}

void stress() {
    mt19937 rnd;
    while (true) {
        int m = rnd() % 8 + 1;
        int n = rnd() % 4 + 1;
        for (int i = 1; i <= n; i++) {
            a[i] = 0;
        }
        for (int i = 1; i <= m; i++) {
            int x = rnd() % n + 1;
            a[x]++;
        }
        Mint ans = solve(n);
        Mint res = slow(n);
        if (ans == res) {
            cout << "OK" << endl;
        } else {
            cout << "WA\n";
            break;
        }
    }
    exit(0);
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef LOCAL
    freopen("input.txt", "r", stdin);
#endif

    // stress();

    int n;
    cin >> n;
    for (int i = 1; i <= n; i++) {
        cin >> a[i];
    }
    cout << solve(n) << "\n";

#ifdef LOCAL
    cout << "\nTime elapsed: " << double(clock()) / CLOCKS_PER_SEC << " s.\n";
#endif
}