#include <vector>
#include <set>
#include <string>
#include <algorithm>
#include <numeric>
#include <functional>
#include <iterator>
#include <limits>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <cstdint>
#include <cassert>

using namespace std;

#define FOR(i, start, end) for(int i = (start); i < (end); ++i)
#define REP(i, n) FOR(i, 0, n)

constexpr int MODULO = 1000000007;

void read_problem(int& n, vector<int>& a)
{
    scanf("%d\n", &n);

    a.resize(n+1);
    REP(i, n+1) {
        scanf("%d", &a[i]);
    }
}

// a^b (mod p)
int pow_modulo(int a, int b, int p)
{
    if(b == 0) return 1;

    if(b % 2 == 0) {
        long d = pow_modulo(a, b/2, p);
        return (d*d) % p;
    }
    else {
        long tmp = a;
        tmp *= pow_modulo(a, b-1, p);
        return tmp % p;
    }
}

// lhs/rhs (mod p), p は素数
int div_modulo(int lhs, int rhs, int p)
{
    long rhs_inv = pow_modulo(rhs, p-2, p);
    return (lhs * rhs_inv) % p;
}

int comb_modulo(int n, int k, int p)
{
    long result = 1;

    for(int i = n; i >= n-k+1; --i) {
        result *= i;
        result %= p;
    }

    for(int i = k; i >= 2; --i) {
        result = div_modulo(result, i, p);
    }

    return result;
}

void find_lr(const vector<int>& a, int& l, int& r)
{
    int n = a.size() - 1;
    vector<int> bin(n+1);

    int dup_num = -1;
    for(int e : a) {
        if(++bin[e] == 2) {
            dup_num = e;
            break;
        }
    }

    for(int i = 0; i < n+1; ++i) {
        if(a[i] == dup_num) {
            l = i;
            break;
        }
    }

    for(int i = n; i >= 0; --i) {
        if(a[i] == dup_num) {
            r = i;
            break;
        }
    }
}

int fac_table[100002];
int fac_inv_table[100002];

void init_fac_table()
{
    long value = 1;
    fac_table[0] = fac_table[1] = 1;
    fac_inv_table[0] = fac_inv_table[1] = 1;

    for(int i = 2; i < 100002; ++i) {
        value *= i;
        value %= MODULO;
        fac_table[i] = value;

        long inv = fac_inv_table[i-1];
        inv *= pow_modulo(i, MODULO-2, MODULO);
        inv %= MODULO;
        fac_inv_table[i] = inv;
    }
}

// C(n,k) = n! / k!(n-k)!
int comb_modulo_fast(int n, int k)
{
#if 0
    long value = fac_table[n];
    value = div_modulo(value, fac_table[k], MODULO);
    value = div_modulo(value, fac_table[n-k], MODULO);
    return value;
#endif
#if 0
    long value = fac_table[n];
    long value_div = fac_table[k];
    value_div *= fac_table[n-k];
    value_div %= MODULO;
    return div_modulo(value, value_div, MODULO);
#endif
    if(n < k) return 0;

    long value = fac_table[n];
    value *= fac_inv_table[k];
    value %= MODULO;
    value *= fac_inv_table[n-k];
    value %= MODULO;
    return value;
}

int main()
{
    init_fac_table();

    int n;
    vector<int> a;
    read_problem(n, a);
#if 0
    REP(i, n+1) {
        printf("%d ", a[i]);
    }
    puts("");
#endif

    //printf("%d\n", pow_modulo(4, 3, MODULO));
    //printf("%d\n", pow_modulo(2, 5, MODULO));
    //printf("%d\n", pow_modulo(2, 31, MODULO));
    //printf("%d\n", pow_modulo(2, 32, MODULO));
    //printf("%d\n", pow_modulo(2, MODULO-2, MODULO));
    //printf("%d\n", pow_modulo(3, MODULO-2, MODULO));
    //printf("%d\n", div_modulo(4, 2, MODULO));
    //printf("%d\n", div_modulo(24, 2, MODULO));
    //printf("%d\n", div_modulo(24, 3, MODULO));
    //printf("%d\n", comb_modulo(4, 3, MODULO));

    int l, r;
    find_lr(a, l, r);
    //printf("l:%d r:%d\n", l, r);

#if 0
    FOR(k, 1, n+2) {
        long comb_all = comb_modulo(n+1, k, MODULO);
        long comb_dup = comb_modulo(l + n-r, k-1, MODULO);
        long result = ((comb_all + MODULO) - comb_dup) % MODULO;
        printf("%ld\n", result);
    }
#endif

    //printf("%d\n", comb_modulo_fast(4, 2));

    FOR(k, 1, n+2) {
        long comb_all = comb_modulo_fast(n+1, k);
        long comb_dup = comb_modulo_fast(l + n-r, k-1);
        long result = ((comb_all + MODULO) - comb_dup) % MODULO;
        printf("%ld\n", result);
    }

    return 0;
}


Measured memory_bytes: 2424