#[allow(unused_macros)]
macro_rules! parse_line {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            iter.next().unwrap().parse::<$t>().unwrap()
        }
    );

    ( $( $t:ty), +) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let mut iter = line.split_whitespace();
            ( $(iter.next().unwrap().parse::<$t>().unwrap()),* )
        }
    );
}

#[allow(unused_macros)]
macro_rules! read_line {
    () => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            line.pop();
            line
        }
    )
}

#[allow(unused_macros)]
macro_rules! parse_vec {
    ( $t:ty ) => (
        {
            let mut line = String::new();
            ::std::io::stdin().read_line(&mut line).unwrap();
            let iter = line.split_whitespace();
            iter.map(|v| v.parse::<$t>().unwrap()).collect::<Vec<_>>()
        }
    )
}

const FACT_MAX: usize = 300000;
const MOD: i64 = 1000000007;

#[allow(dead_code)]
fn pow_mod(base: i64, power: i64, modulo: i64) -> i64 {
    let mut base = base;
    let mut power = power;
    let mut ans = 1;
    while power > 0 {
        if power & 1 == 1 {
            ans = ans * base % modulo;
        }
        power >>= 1;
        base = base * base % modulo;
    }
    ans
}

thread_local! {
    #[allow(unused)]
    pub static FACT: Vec<i64> = {
        let mut fac: Vec<i64> = vec![1; FACT_MAX+1];

        for i in 1..FACT_MAX+1 {
            fac[i] = (fac[i-1] * i as i64) as i64 % MOD;
        }
        fac
    };

    #[allow(unused)]
    pub static RFACT: Vec<i64> = {
        let mut rfac = vec![1; FACT_MAX+1];
        rfac[FACT_MAX] = FACT.with(|fact| {
            pow_mod(fact[FACT_MAX], MOD-2, MOD)
        });

        for i in (0..FACT_MAX).rev() {
            rfac[i] = (rfac[i+1] * (i+1) as i64) % MOD;
        }
        rfac
    }
}

#[allow(dead_code)]
fn combi(n: usize, m: usize) -> i64 {
    if n < m {
        return 0;
    }

    FACT.with(|fact| {
        RFACT.with( |rfact| {
            fact[n] * rfact[n-m] % MOD * rfact[m] % MOD
        })
    })
}

fn dup_pos(aa: Vec<usize>) -> (usize, usize) {
    let mut t = vec![std::usize::MAX; aa.len()];
    for (i, &a) in aa.iter().enumerate() {
        if t[a] == std::usize::MAX {
            t[a] = i;
        } else {
            return (t[a], i)
        }
    }

    unreachable!()
}

fn solve(aa: Vec<usize>) -> Vec<i64> {
    use std::cmp::{max, min};

    let n = aa.len();
    let (p1, p2) = dup_pos(aa);

//    println!("p1={}, p2={}", p1, p2);

    let mut ret = Vec::new();

    let mut p2_acc = vec![0; n];
    p2_acc[0] = 1;
    for i in 1..(n-p2) {
        p2_acc[i] += combi(n-p2-1, i) + p2_acc[i-1];
        p2_acc[i] %= MOD;
    }

//    println!("{:?}", p2_acc);

    for i in 1..(n+1) {
        let mut c = combi(n,i);
        c += MOD - combi(p1+n-1-p2, i-1);
        c %= MOD;
        ret.push(c);
    }

    ret
}

fn main() {
    read_line!();
    let aa = parse_vec!(usize);

    for r in solve(aa) {
        println!("{}", r);
    }
}

#[test]
fn solve_test() {
    assert_eq!(solve(vec![1,2,1,3]), vec![3,5,4,1]);
    assert_eq!(solve(vec![1,1]), vec![1,1]);

    assert_eq!(solve(vec![29,19,7,10,26,32,27,4,11,20,2,8,16,23,5,14,6,12,17,22,18,30,28,24,15,1,25,3,13,21,19,31,9]), vec![32,525,5453,40919,237336,1107568,4272048,13884156,38567100,92561040,193536720,354817320,573166440,818809200,
                                                                                                                            37158313,166803103,166803103,37158313,818809200,573166440,354817320,193536720,92561040,38567100,13884156,
                                                                                                                            4272048,1107568,237336,40920,5456,528,33,1]);
}


Measured memory_bytes: 16500