//####################################################################
//#####In the Name Of Allah,the Most Gracious,the Most Merciful.######
//####################################################################
//############Created by Sazid Rahman Simanto on 3/20/17.#############
//#####Copyright 2017 Sazid Rahman Simanto. All rights reserved.######
//####################################################################

#include <iostream>
#include <string>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <map>
#include <set>
#include <string>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include <utility>
#include <bitset>
#include <list>
#include <algorithm>
#include <complex>

using namespace std;
//#include <ext/pb_ds/assoc_container.hpp>
//#include <ext/pb_ds/tree_policy.hpp>
//using namespace __gnu_pbds;

#define MSET(a,x) memset(a,x,sizeof a)
#define FOR(i,x,y) for(int i=(x);i<=(y);i++)
#define FORR(i,x,y) for(int i=(x);i<(y);i++)
#define ROF(i,x,y) for(int i=(y);i>=(x);i--)
#define SQ(x) ((x)*(x))
#define ALL(x) (x).begin(),(x).end()
#define SZ(x) ((int)(x).size())
#define ff first
#define ss second
#define pb push_back
#define inf             1061109567
#define maxn            100010
#define esp             1e-8
#define mod             1000000007
#define ll              long long
#define ull             unsigned long long
#define pii             pair<int,int>
#define pll             pair<ll,ll>
#define read()          freopen("input.txt", "r", stdin)
#define write()         freopen("output.txt", "w", stdout)
#define MOD 1000000007
//typedef tree <int, null_type, less<int>, rb_tree_tag, tree_order_statistics_node_update> pb_ds;

typedef pair<int , int> ii;
typedef complex<double> base;
const double PI = acos(- 1);


ll bigmod(ll N,ll P){
        if(P < 0) return 0;
	if(P == 0) return 1;
	if(P%2 == 0){
		ll ret = bigmod(N,P/2);
		return ((ret%MOD)*(ret%MOD))%MOD;
	}else{
		return ((N%MOD)*(bigmod(N,P-1)%MOD))%MOD;
	}
}
template <class T> inline T gcd ( T a, T b ) {

        while (b) {
                a = a % b;
                swap ( a, b );
        }
        return a;
}


template <class T> inline T lcm(T a, T b) { return (a / gcd(a, b)) * b; }

template <class T> inline T poww(T a, T b) {
        ll ret = 1;
        for(; b > 0; b >>= 1) {
                if(b & 1) ret = ret * a;
                a = a * a;
        }
        return (T)ret;
}

pii exEuclid(int a, int b) {
        if(b == 0) return pii(1, 0);
        else {
                pii r = exEuclid(b, a % b);
                return pii(r.ss, r.ff - r.ss * (a / b));
        }
}

int modInv(int a, int m) { pii ret = exEuclid(a, m); return ((ret.ff % m) + m ) % m; }



int Set(int N, int pos) {return N = N | (1 << pos);}
int reset(int N, int pos) {return N = N & ~ (1 << pos);}
bool check(int N, int pos) {return (bool) (N & (1 << pos));}

//####################################################################
//##################Template Ends Here################################
//####################################################################
int n, cnt[maxn], x, l, r;
ll fac[maxn];
vector<pii> v;

ll nCr(int nn, int rr)
{
        if(nn < rr) return 0;
        if(rr == 0 || nn == rr) return 1;
        if(rr > nn / 2) rr = nn - rr;
        ll ret = ((fac[rr] % mod) * (fac[nn - rr] % mod)) % mod;
        ret = modInv(ret, mod);
        ret = ((ret % mod) * (fac[nn] % mod)) % mod;
        return ret;
}

int main() {

        //read();
        //ios_base::sync_with_stdio(false); cin.tie(NULL);cout.tie(NULL);
        //write();
        cin >> n;
        fac[0] = fac[1] = 1;
        FOR(i, 2, 100001){
                fac[i] = ((fac[i - 1] % mod) * (i % mod)) % mod;
        }
        FOR(i, 1, n + 1){
                cin >> x;
                cnt[x] ++;
                v.pb(pii(x, i));
        }
        sort(ALL(v));
        FORR(i, 0, n + 1){
                if(cnt[v[i].ff] == 2){
                        l = v[i].ss;
                        r = v[i + 1].ss;
                        break;
                }
        }
        FOR(k, 1, n + 1){
                ll ans = nCr(n + 1, k) - nCr(l - 1 + (n + 1 - r), k - 1);
                if(ans < 0) ans += mod;
                printf("%lld\n", ans);
        }


        return 0;

}


Measured memory_bytes: 3316