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

/* Modint */
template <typename T, T MOD = 1000000007>
struct ModInt {
    static constexpr T mod = MOD;
    T v;
    ModInt() : v(0) {}
    ModInt(long long t) { v = t >= 0 ? t % mod : (mod - (-t) % mod) % mod; }

    ModInt pow(long long k) {
        ModInt res(1), tmp(v);
        while(k) {
            if(k & 1) res *= tmp;
            tmp *= tmp;
            k >>= 1;
        }
        return res;
    }

    static ModInt add_identity() { return ModInt(0); }
    static ModInt mul_identity() { return ModInt(1); }

    ModInt inv() { return pow(MOD - 2); }

    ModInt &operator+=(ModInt a) {
        v += a.v;
        if(v >= MOD) v -= MOD;
        return *this;
    }
    ModInt &operator-=(ModInt a) {
        v += MOD - a.v;
        if(v >= MOD) v -= MOD;
        return *this;
    }
    ModInt &operator*=(ModInt a) {
        v = 1LL * v * a.v % MOD;
        return *this;
    }
    ModInt &operator/=(ModInt a) { return (*this) *= a.inv(); }

    ModInt operator+(ModInt a) const { return ModInt(v) += a; };
    ModInt operator-(ModInt a) const { return ModInt(v) -= a; };
    ModInt operator*(ModInt a) const { return ModInt(v) *= a; };
    ModInt operator/(ModInt a) const { return ModInt(v) /= a; };

    ModInt operator-() const { return v ? ModInt(MOD - v) : ModInt(v); }

    bool operator==(const ModInt a) const { return v == a.v; }
    bool operator!=(const ModInt a) const { return v != a.v; }
    bool operator<(const ModInt a) const { return v < a.v; }

    // find x s.t. a^x = b
    static T log(T a, T b) {
        const T sq = 40000;
        unordered_map<T, T> dp;
        dp.reserve(sq);
        ModInt res(1);
        for(int r = 0; r < sq; r++) {
            if(!dp.count(res.v)) dp[res.v] = r;
            res *= a;
        }
        ModInt p = ModInt(a).inv().pow(sq);
        res = b;
        for(int q = 0; q <= MOD / sq + 1; q++) {
            if(dp.count(res.v)) {
                T idx = q * sq + dp[res.v];
                if(idx > 0) return idx;
            }
            res *= p;
        }
        assert(0);
        return T(-1);
    }

    static ModInt perm(long long n, int k) {
        ModInt num(1);
        for(int i = 0; i < k; i++) {
            num *= ModInt(n - i);
        }
        return num;
    }

    static ModInt comb(long long n, int k) {
        ModInt num(1), dom(1);
        for(int i = 0; i < k; i++) {
            num *= ModInt(n - i);
            dom *= ModInt(i + 1);
        }
        return num / dom;
    }

    friend ostream &operator<<(ostream &os, ModInt<T, MOD> m) {
        os << m.v;
        return os;
    }
};
template <typename T, T MOD>
constexpr T ModInt<T, MOD>::mod;

int64_t power(int64_t x, int64_t n, int64_t mod) {
    int64_t ret = 1;
    while(n > 0) {
        if(n & 1) (ret *= x) %= mod;
        (x *= x) %= mod;
        n >>= 1;
    }
    return ret;
}

auto ng = [](int x) {
    cout << x << endl;
    exit(0);
};

int main() {
    using mint = ModInt<long long, 998244353>;
    int N;
    cin >> N;
    vector<int> D(N);
    for(int i = 0; i < N; i++) cin >> D[i];
    if(D[0] != 0) ng(0);
    sort(D.begin(), D.end());
    if(D[1] == 0) ng(0);

    map<int, int> counter;
    for(auto x : D) {
        counter[x]++;
    }
    mint ans(1);
    for(size_t i = 1; i <= D[N - 1]; i++) {
        ans *= power(counter[i - 1], counter[i], 998244353);
    }
    cout << ans << endl;

    return 0;
};

Measured memory_bytes: 5376