// !!!!!!
// rename to template.cpp instead of main.cpp
#include <bits/stdc++.h>

#define fr first
#define sc second
#define all(a) (a).begin(), (a).end()

using namespace std;

#ifdef ONPC
mt19937 rnd(223);
#else
mt19937 rnd(chrono::high_resolution_clock::now()
                    .time_since_epoch().count());
#endif

#define TIME (clock() * 1.0 / CLOCKS_PER_SEC)
template<typename T, typename U>
ostream& operator << (ostream& o, const pair<T, U>& p) {
    return o << "(" << p.first << ", " << p.second << ")";
}
template<typename T>
ostream& operator << (ostream& o, const vector<T>& v) {
    bool first = true;
    o << "[";
    for (const auto& l : v) {
        if (!first) o << ", ";
        o << l;
        first = false;
    }
    return o << "]";
}
template<typename T>
ostream& operator << (ostream& o, const set<T>& v) {
    bool first = true;
    o << "{";
    for (const auto& l : v) {
        if (!first) o << ", ";
        o << l;
        first = false;
    }
    return o << "}";
}
#ifdef ONPC
#define show(x) cout << "LINE " << __LINE__ << ": " << #x << "=" << x << std::endl;
#else
#define show(x) 42
#endif

using ll = long long;
using ld = double;

const int MOD = 1'000'000'007;

using ull = unsigned long long;
template <int MD>
struct ModInt {
    using M = ModInt;
//    static int MD;
    int v;
    ModInt(ll _v = 0) { set_v(int(_v % MD + MD)); }
    inline M& set_v(int _v) {
        v = (_v < MD) ? _v : _v - MD;
        return *this;
    }
    inline explicit operator bool() const { return v != 0; }
    inline M operator-() const { return M() - *this; }
    inline M operator+(const M& r) const { return M().set_v(v + r.v); }
    inline M operator-(const M& r) const { return M().set_v(v + MD - r.v); }
    inline M operator*(const M& r) const { return M().set_v(int((ull)v * r.v % MD)); }
    inline M operator/(const M& r) const { return *this * r.inv(); }
    inline M& operator+=(const M& r) { return *this = *this + r; }
    inline M& operator-=(const M& r) { return *this = *this - r; }
    inline M& operator*=(const M& r) { return *this = *this * r; }
    inline M& operator/=(const M& r) { return *this = *this / r; }
    inline bool operator==(const M& r) const { return v == r.v; }
    inline bool operator!=(const M& r) const { return v != r.v; }
    inline M inv() const;
    inline friend istream& operator>>(istream& is, M& r) { ll x; is >> x; r = M(x); return is; }
    inline friend ostream& operator<<(ostream& os, const M& r) { return os << r.v; }
};

template<int MD>
ModInt<MD> pow(ModInt<MD> x, ll n) {
//ModInt pow(ModInt x, ll n) {
    ModInt<MD> r = 1;
    //ModInt r = 1;
    while (n) {
        if (n & 1) r *= x;
        x *= x;
        n >>= 1;
    }
    return r;
}

template<int MD>
ModInt<MD> ModInt<MD>::inv() const { return pow(*this, MD - 2); }
//ModInt ModInt::inv() const { return pow(*this, MD - 2); }

// if MD is from input
// this line is necessary, read later as you wish
//int ModInt::MD;

using Mint = ModInt<MOD>;

const int M = 1010;

Mint c[M][M];
Mint ipw2[M * M];

void solve() {
    int n;
    cin >> n;
    vector<int> cnt(51);
    for (int i = 0; i < n; i++) {
        int x;
        cin >> x;
        cnt[x]++;
    }

    vector<Mint> pwn(n + 1);
    for (int k = 0; k <= n; k++) {
        pwn[k] = 1;
        for (int i = 0; i < n; i++) {
            pwn[k] *= k;
        }
    }
    Mint fact = 1;
    for (int i = 1; i <= n; i++) {
        fact *= i;
    }
    Mint ifact = Mint(1) / fact;

    vector<Mint> dp(n);
    Mint prev = 0;
    for (int i = 0; i < n; i++) {
        Mint cur = 0;
        for (int k = 0; k <= i + 1; k++) {
            Mint term = c[n][k] * pwn[i + 1 - k];
            if (k & 1) {
                cur -= term;
            } else {
                cur += term;
            }
        }
        cur *= ifact;
        dp[i] = cur - prev;
        prev = cur;
    }

    vector<int> suf(cnt.begin() + 1, cnt.end());
    for (int i = (int)suf.size() - 2; i >= 0; i--) {
        suf[i] += suf[i + 1];
    }

    show(suf);
    show(dp);
    show(cnt);

    int tot = accumulate(suf.begin(), suf.end(), 0);
    Mint ans = dp[0] * cnt[0] * ipw2[tot];
    for (int i = 0; i < 50 && tot > 0; i++) {
        vector<Mint> poly(suf[i] + 1);
        for (int k = 0; k <= suf[i]; k++) {
            poly[k] = c[suf[i]][k] * ipw2[suf[i]];
        }
        show(poly);

        vector<Mint> new_dp(dp.size() + poly.size() - 1);
        for (int x = 0; x < (int)dp.size(); x++) {
            for (int y = 0; y < (int)poly.size(); y++) {
                new_dp[x + y] += dp[x] * poly[y];
            }
        }
        vector<Mint> new_dp_2((new_dp.size() + 1) / 2);
        for (int x = 0; x < (int)new_dp.size(); x++) {
            new_dp_2[x / 2] += new_dp[x];
        }
        swap(dp, new_dp_2);

        tot -= suf[i];
        ans += dp[0] * cnt[i + 1] * ipw2[tot];
    }

    cout << Mint(1) - ans << "\n";
}

int main() {
#ifdef ONPC
    freopen("input", "r", stdin);
#endif
    ios::sync_with_stdio(0); cin.tie(0);
    cout << fixed << setprecision(20);

    for (int i = 0; i < M; i++) {
        c[i][0] = 1;
    }
    for (int j = 1; j < M; j++) {
        for (int i = j; i < M; i++) {
            c[i][j] = c[i - 1][j - 1] + c[i - 1][j];
        }
    }
    Mint step = Mint(1) / 2;
    ipw2[0] = 1;
    for (int i = 1; i < M * M; i++) {
        ipw2[i] = ipw2[i - 1] * step;
    }

    int t = 1;
    //cin >> t;
    while (t--) {
        solve();
    }

    cerr << "\n\nConsumed " << TIME << endl;
}