#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define pb push_back
#define mp make_pair
#define all(a) begin(a),end(a)
#define FOR(x,val,to) for(int x=(val);x<int((to));++x)
#define FORE(x,val,to) for(auto x=(val);x<=(to);++x)
#define FORR(x,arr) for(auto &x: arr)
#define FORS(x,plus,arr) for(auto x = begin(arr)+(plus); x != end(arr); ++x)
#define FORREV(x,plus,arr) for(auto x = (arr).rbegin()+(plus); x !=(arr).rend(); ++x)
#define REE(s_) {cout<<s_<<'\n';exit(0);}
#define GET(arr) for(auto &i: (arr)) sc(i)
#define whatis(x) cerr << #x << " is " << (x) << endl;
#define e1 first
#define e2 second
#define INF 0x7f7f7f7f
typedef std::pair<int,int> pi;
typedef std::vector<int> vi;
typedef std::vector<std::string> vs;
typedef int64_t ll;
typedef uint64_t ull;
#define umap unordered_map
#define uset unordered_set
using namespace std;
using namespace __gnu_pbds;

#ifdef ONLINE_JUDGE
#define whatis(x) ;
#endif
#ifdef _WIN32
#define getchar_unlocked() _getchar_nolock()
#define _CRT_DISABLE_PERFCRIT_LOCKS
#endif
template<class L, class R> ostream& operator<<(ostream &os, map<L, R> P) { for(auto const &vv: P)os<<"("<<vv.first<<","<<vv.second<<")"; return os; }
template<class T> ostream& operator<<(ostream &os, set<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class T> ostream& operator<<(ostream &os, vector<T> V) { os<<"[";for(auto const &vv:V)os<<vv<<","; os<<"]"; return os; }
template<class L, class R> ostream& operator<<(ostream &os, pair<L, R> P) { os<<"("<<P.first<<","<<P.second<<")"; return os; }
inline int fstoi(const string &str){auto it=str.begin();bool neg=0;int num=0;if(*it=='-')neg=1;else num=*it-'0';++it;while(it<str.end()) num=num*10+(*it++-'0');if(neg)num*=-1;return num;}
inline void getch(char &x){while(x = getchar_unlocked(), x < 33){;}}
inline void getstr(string &str){str.clear(); char cur;while(cur=getchar_unlocked(),cur<33){;}while(cur>32){str+=cur;cur=getchar_unlocked();}}
template<typename T> inline bool sc(T &num){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){if(c == EOF) return false;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; return true;}template<typename T, typename ...Args> inline void sc(T &num, Args &...args){ bool neg=0; int c; num=0; while(c=getchar_unlocked(),c<33){;} if(c=='-'){ neg=1; c=getchar_unlocked(); } for(;c>47;c=getchar_unlocked()) num=num*10+c-48; if(neg) num*=-1; sc(args...); }
template<typename T> using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>; //s.find_by_order(), s.order_of_key() <- works like lower_bound
template<typename T> using ordered_map = tree<T, int, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define N 5001

constexpr int64_t mod = 1000000007;

inline int64_t fastpow(int64_t a, int64_t b){
    if(b == 0)
        return 1;
    if(b&1){
        return (a * fastpow(a,b^1)) % mod;
    }
    a = fastpow(a,b >> 1);
    return (a*a)%mod;
}

ll fac[N];
ll invfac[N];
ll bin(ll n, ll k){
    ll res = fac[n];
    res *= invfac[k];
    res %= mod;
    res *= invfac[n-k];
    res %= mod;
    return res;
}

void pre(){
    fac[0] = 1;
    FOR(i,1,N){
        fac[i] = fac[i-1]*i%mod;
    }
    FOR(i,0,N){
        invfac[i] = fastpow(fac[i],mod-2);
    }
}
int main(){
    ios_base::sync_with_stdio(0);cin.tie(0);
    pre();
    int n;
    sc(n);
    int a[n];
    GET(a);
    sort(a,a+n);
    map<int,int> els;
    FORR(i,a)
        ++els[i];
    /* int dptaken[n]; */
    /* int dpnottaken[n]; */
    // mozemy do maxa => mozemy az do sumy -> += all dpnottaken do tej sumy inc
    // ale wait, czyli jeszcze sumę elementów do maxa muszę znać
    // wait, ale sumy są O(n^2) przecie a nie O(n)
    /* const int maxs = 10; */
    const int maxs = 5010;
    // wtf, jednak maxs musi być faktycznie równe sumie
    // -> przypau?
    // zawsze moge spamietywac updaty -> jakies lazy lol
    // ale still, tego nxsuma jest i guess

    // nie no, wystarczy to scappować w tym sensie, że jeśli coś byśmy dodali /
    // chcielo od czegoś >= maxs, to po prostu bierzemy to od maxs - 1

    /* ll dptaken[n][maxs]; */
    /* ll dptaken[maxs][maxs]; */
    /* ll dptaken[maxs]; // nie mam tyle pamięci żeby tą trzymać w 2d -> reset co inny prev */
    /* ll dpnottaken[n][maxs]; // z elementami < */
    ll dpnottaken[maxs][maxs]; // z elementami <
    // chyba może mi wystarczyć 1 wymiar tego dpnottakien cnie?
    // -> segtree na tym
    // dptaken jest w pełni tymczasowe, więc je można też pominąć
    /* memset(dptaken,0,sizeof dptaken); */
    memset(dpnottaken,0,sizeof dpnottaken);
    ll res = 0;
    // base of dp
    dpnottaken[0][0] = 1;
    /* int p = 1; */
    /* int p = 2; */
    int p = 3;
    FORR(i,els){
        // dpnottaken dla siebie tutaj nie modyfikujemy, jedynie dptaken
        // przyszła suma zależy od tego ile swoich elementów weźniemy
        // wait, ale na sumy potrzebuję wtedy więcej
        // unless dp[2], segtree or sth??
        // albo zaś trick jak w minach z invalidacją pewnych sum
        // może kompresja sum or sth?
        // no bo dla nas te sumy mają jedynie znaczenie aby wiedzieć do jakiego
        // elementu na przedziale dodać nowy wyliczone dptaken

        // pomijańsko tutaj robiłem mocne lol
        /* if(i.e1 != 1){ */
        /* while(i.e1 > p){ */
        while(i.e1 >= p){
            // -> lol, metodą prób i błędów w końcu git
        /* while(i.e1 > p){ */
            /* for(int s = 1; s < maxs; ++s){ */
            for(int s = 0; s < maxs; ++s){
                /* dpnottaken[i][s] += dpnottaken[i][s-1]; */
                /* dpnottaken[i][s] %= mod; */
                // wait, nie po tym wymiarze dodaję prefowo przecie lol
                /* dpnottaken[i.e1 - 1][s] += dpnottaken[i.e1 - 1][s - 1]; */
                /* dpnottaken[i.e1 - 1][s] %= mod; */
                // bruh, nice .e2
                /* dpnottaken[i.e1 - 1][s] += dpnottaken[i.e2 - 2][s]; */
                /* dpnottaken[i.e1 - 1][s] += dpnottaken[i.e1 - 2][s]; */
                /* dpnottaken[i.e1 - 1][s] %= mod; */
                dpnottaken[p - 1][s] += dpnottaken[p - 2][s];
                dpnottaken[p - 1][s] %= mod;
            }
            ++p;
        }

        /* whatis(i.e1) */
        for(int cnt = 1; cnt <= i.e2; ++cnt){
            /* whatis(cnt) */
            // C(i.e2, cnt)
            ll ile = bin(i.e2, cnt);
            /* for(int s = i.e1; s < N; ++s){ */
            /* for(int s = cnt * i.e1; s < maxs; ++s){ // mozna w dol / gore, doesn't matter */
            /* for(int s = cnt * i.e1; s < maxs - 1; ++s){ // mozna w dol / gore, doesn't matter */
            // taki warunek jest gitowy?
            for(int s = cnt * i.e1; s - cnt * i.e1 < maxs - 1; ++s){ // mozna w dol / gore, doesn't matter
                // -> chyba całkiem git
                // od dpnottaken[i.e1 - 1], czy od dpnottaken[i.e1] wsm?

                // wait, wsm to trzymanie tego arrayu chyba jednak ma znaczenie
                // przy wielokrotnościach; przynajmniej wcześniej było inne
                // działanie

                /* whatis(dpnottaken[i.e1 - 1][s - cnt * i.e1]) */
                /* ll dptaken = ile * dpnottaken[i.e1 - 1][s - cnt * i.e1]; */
                // sumę potrzebuję wiedzieć po to, aby wiedzieć na jakim rangu
                // będę mógł dodać :?
                ll dptaken = ile * dpnottaken[i.e1 - 1][s - cnt * i.e1];
                // zamień na segtree
                /* dptaken[i.e2][s] %= mod; */
                dptaken %= mod;
                // lol, złą rzecz modulowałem btw -> może dlatego tylko 2 punkty wsm, a niekoniecznie tle

                // zamieniamy nasz s na ss -> minujemy z mozliwym maxem, bo
                // wyzszych nie ma sensu trzymac
                ll ss = min(s,maxs-2);
                // -> chyba całkiem git
                /* for(int j = i.e1; j <= min(s,maxs-1); ++j){ */
                /* for(int j = i.e1; j <= ss; ++j){ */
                /*     /1* dpnottaken[j][s] += dptaken[i.e1][s]; *1/ */
                /*     /1* dpnottaken[j][s] += dptaken; *1/ */
                /*     /1* dpnottaken[j][s] %= mod; *1/ */
                /*     /1* dpnottaken[j][ss] += dptaken; *1/ */
                /*     /1* dpnottaken[j][ss] %= mod; *1/ */
                /* } */
                // ->pref sum
                /* dpnottaken[i.e1][s] += dptaken; */
                /* dpnottaken[i.e1][s] %= mod; */
                /* dpnottaken[s + 1][s] -= dptaken; */
                /* dpnottaken[s + 1][s] %= mod; */
                dpnottaken[i.e1][ss] += dptaken;
                dpnottaken[i.e1][ss] %= mod;
                dpnottaken[ss + 1][ss] -= dptaken;
                dpnottaken[ss + 1][ss] %= mod;
                /* dpnottaken[min(s,maxs-2) + 1][s] -= dptaken; */
                /* dpnottaken[min(s,maxs-2) + 1][s] %= mod; */
                /* res += dptaken[i.e1][s]; */
                res += dptaken;
                res %= mod;
            }
        }
        /* for(int cnt = 1 ; cnt <= i.e2; ++cnt){ */
            // C(i.e2, cnt)
            /* int ile; */
            /* for(int s = i.e1; s < N; ++s){ */
            /* for(int s = i.e1; s < maxs; ++s){ // mozna w dol / gore, doesn't matter */
            /*     // od dpnottaken[i.e1 - 1], czy od dpnottaken[i.e1] wsm? */
            /*     // tutaj mogę skompresować to, aby łazić po sumach dla */
            /*     // konkretnych elementów po prostu */
            /*     /1* for(int j = i.e1; j <= s; ++j){ *1/ */
            /*     for(int j = i.e1; j <= min(s,maxs-1); ++j){ */
            /*         dpnottaken[j][s] += dptaken[i.e1][s]; */
            /*         dpnottaken[j][s] %= mod; */
            /*     } */
            /*     res += dptaken[i.e1][s]; */
            /*     res %= mod; */
            /* } */
        /* } */
    }
    // simpler to think about, jak o pojedynczych elementach na razie; i działa

    // ale jak mam rosnące wartości w pętli, to mogę łatwiej zastosować + -
    // trick z sumowaniem prefiksowym

    // ale to wsm mogę po prostu trzymać dwie tabeli - normalnego prefa, i
    // punkty do dodania do prefa (+ -), zerowane co kwerendę -> ez poniżej

    // a nie wait, ja zawsze biorę z i - 1 do cura, a updatuję >= i -> nie
    // muszę żadnego dodatkowego trzymać

    // also, pod casea z wieloma punktami, still potrzebuję trzymać dptaken
    // wsm nie mam tyle pamięci żeby tą trzymać w 2d -> reset co inny prev
    // ;tera mam ale whatever

    // sumę mogę przecież po prostu scappować do max wartości

    // nvm, mam wa dla 1 1 1 chociażby, let's do it the old way

    /* int p = a[0]; */
    /* FORR(i,a){ */
    /*     if(i != p){ */
    /*         memset(dptaken,0,sizeof dptaken); */
    /*         // dla pierwszego nie chcę */
    /*         /1* for(int s = 1; s < maxs; ++s){ *1/ */
    /*         /1*     dpnottaken[i][s] += dpnottaken[i][s-1]; *1/ */
    /*         /1*     dpnottaken[i][s] %= mod; *1/ */
    /*         /1* } *1/ */
    /*     } */
    /*     /1* for(int s = i; s < maxs; ++s){ // mozna w dol / gore, doesn't matter *1/ */
    /*     for(int s = i; s < maxs - 1; ++s){ // mozna w dol / gore, doesn't matter */
    /*         // od dpnottaken[i.e1 - 1], czy od dpnottaken[i.e1] wsm? */
    /*         // lol, wcześniej odwoływałem się do [i-1], ale był git bo miałem */
    /*         // dptaken jako spory matrix wyzerowany */
    /*         // wait, nvm, wcale nie bo i najmniej jest 1 */
    /*         dptaken[s] += dpnottaken[i - 1][s - i]; */
    /*         /1* dptaken[s] += i ? dpnottaken[i - 1][s - i] : 1; *1/ */
    /*         // zamień na segtree */
    /*         /1* dptaken[i.e2][s] %= mod; *1/ */
    /*         dptaken[s] %= mod; */
    /*         // lol, złą rzecz modulowałem btw -> może dlatego tylko 2 punkty wsm, a niekoniecznie tle */
    /*         for(int j = i; j <= min(s,maxs-1); ++j){ */
    /*             dpnottaken[j][s] += dptaken[s]; */
    /*             dpnottaken[j][s] %= mod; */
    /*         } */
    /*         // ->pref sum */
    /*         /1* dpnottaken[i][s] += dptaken[s]; *1/ */
    /*         /1* dpnottaken[i][s] %= mod; *1/ */
    /*         /1* dpnottaken[s + 1][s] -= dptaken[s]; *1/ */
    /*         /1* dpnottaken[s + 1][s] %= mod; *1/ */
    /*         /1* dpnottaken[min(s,maxs-2) + 1][s] -= dptaken[s]; *1/ */
    /*         /1* dpnottaken[min(s,maxs-2) + 1][s] %= mod; *1/ */
    /*         /1* dpnottakenqu[i][s] += dptaken[i][s]; *1/ */
    /*         /1* dpnottakenqu[i][s] %= mod; *1/ */
    /*         /1* dpnottakenqu[min(s,maxs-2) + 1][s] -= dptaken[i][s]; *1/ */
    /*         /1* dpnottakenqu[min(s,maxs-2) + 1][s] %= mod; *1/ */
    /*         res += dptaken[s]; */
    /*         res %= mod; */
    /*     } */
    /*     p = i; */
    /* } */
    cout << res << '\n';
    // + pusty?
    // bez pustych chyba
    // lol, przeszło sampla za pierwszym razem XD
    // kodowanie na ślepo
}