#[allow(unused_imports)]
use std::cmp::{max, min};
#[allow(unused_imports)]
use std::collections::{HashMap, HashSet};

mod util {
    use std::io::stdin;
    use std::str::FromStr;
    use std::fmt::Debug;

    #[allow(dead_code)]
    pub fn line() -> String {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().to_string()
    }

    #[allow(dead_code)]
    pub fn get<T: FromStr>() -> T
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.trim().parse().unwrap()
    }

    #[allow(dead_code)]
    pub fn gets<T: FromStr>() -> Vec<T>
    where
        <T as FromStr>::Err: Debug,
    {
        let mut line: String = String::new();
        stdin().read_line(&mut line).unwrap();
        line.split_whitespace()
            .map(|t| t.parse().unwrap())
            .collect()
    }
}


fn gcd(a: usize, b: usize) -> usize {
    if b == 0 { a } else { gcd(b, a % b) }
}


fn lcm(a: usize, b: usize) -> usize {
    a * b / gcd(a, b)
}

// (gcd, x, y)
fn extgcd(a: i64, b: i64) -> (i64, i64, i64) {
    if b == 0 {
        (a, 1, 0)
    } else {
        let (gcd, x, y) = extgcd(b, a % b);
        (gcd, y, x - (a / b) * y)
    }
}

fn mod_pow(x: usize, n: usize, m: usize) -> usize {
    let mut res = 1;
    let mut x = x;
    let mut n = n;
    while n > 0 {
        if n & 1 == 1 {
            res = (res * x) % m;
        }
        x = (x * x) % m;
        n = n >> 1;
    }
    res
}


fn mod_inverse(a: usize, m: usize) -> usize {
    let (_, x, _) = extgcd(a as i64, m as i64);
    ((m as i64 + x) as usize % m) % m
}

fn fact_table(len: usize, m: usize) -> Vec<usize> {
    let mut res = vec![1; len];
    for i in 1..len {
        res[i] = (i * res[i - 1]) % m;
    }
    res
}


// (a mod p, e when n! = a p^e)
fn mod_fact(n: usize, p: usize, fact: &Vec<usize>) -> (usize, usize) {
    if n == 0 {
        (1, 0)
    } else {
        let (a, b) = mod_fact(n / p, p, fact);
        let e = b + n / p;

        if n / p % 2 != 0 {
            (a * (p - fact[n % p]) % p, e)
        } else {
            (a * fact[n % p] % p, e)
        }
    }
}

fn mod_comb(n: usize, k: usize, p: usize, fact: &Vec<usize>) -> usize {
    if k == 0 {
        return 1;
    }
    if n < k {
        0
    } else {
        let (a1, e1) = mod_fact(n, p, fact);
        let (a2, e2) = mod_fact(k, p, fact);
        let (a3, e3) = mod_fact(n - k, p, fact);

        if e1 > e2 + e3 {
            0
        } else {
            a1 * mod_inverse(a2 * a3 % p, p) % p
        }
    }
}

const M: usize = 1000_000_007;
fn main() {
    let n: usize = util::get();
    let a: Vec<usize> = util::gets();


    let dupe = {
        let mut set = HashSet::new();
        let mut r = 0;
        for &x in &a {
            if set.contains(&x) {
                r = x;
                break;
            }
            set.insert(x);
        }
        r
    };

    let dupe_pos: Vec<usize> = (0..n + 1).filter(|&i| a[i] == dupe).collect();

    println!("{}", n);
    let fact = fact_table(n + 2, M);
    for k in 2..n + 2 {
        let a = mod_comb(n + 1, k, M, &fact);
        let b = mod_comb(dupe_pos[0] + n - dupe_pos[1], k - 1, M, &fact);

        println!("{}", (a + M - b) % M);
    }
}


Measured memory_bytes: 9464