Problem:
Score : 600 points

Problem Statement

Takahashi has N cards. The i-th of these cards has an integer A_i written on it.

Takahashi will choose an integer K, and then repeat the following operation some number of times:

Choose exactly K cards such that the integers written on them are all different, and eat those cards. (The eaten cards disappear.)

For each K = 1,2, \ldots, N, find the maximum number of times Takahashi can do the operation.

Constraints

1 \le N \le 3 \times 10^5

1 \le A_i \le N

All values in input are integers.

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \ldots A_N

Output

Print N integers.
The t-th (1 \le t \le N) of them should be the answer for the case K=t.

Sample Input 1

3
2 1 2

Sample Output 1

3
1
0

For K = 1, we can do the operation as follows:

Choose the first card to eat.

Choose the second card to eat.

Choose the third card to eat.

For K = 2, we can do the operation as follows:

Choose the first and second cards to eat.

For K = 3, we cannot do the operation at all. Note that we cannot choose the first and third cards at the same time.

Sample Input 2

5
1 2 3 4 5

Sample Output 2

5
2
1
1
1

Sample Input 3

4
1 3 3 3

Sample Output 3

4
1
0
0

Solution in Rust (1.15.1) (judge verdict: Wrong Answer)

use std::io::*;
use std::cmp::*;


macro_rules! parse {
    ($s:expr, $($r:tt)*) => {
        let mut it = $s.trim().split_whitespace();
        _let!{it, $($r)*}
    };
}


macro_rules! _let {
    ($it:expr, ) => {};
    ($it:expr, $var:ident : $t:tt) => {
        let $var = _parse!($it, $t);
    };
    ($it:expr, $var:ident : $t:tt, $($r:tt)*) => {
        _let!{$it, $var : $t};
        _let!{$it, $($r)*};
    };
}


macro_rules! _parse {
    ($it:expr, ( $($t:tt),* )) => {
        ( $(_parse!($it, $t)),* )
    };
    ($it:expr, [ $t:tt ; $n:expr ]) => {
        (0..$n).map(|_| _parse!($it, $t)).collect::<Vec<_>>()
    };
    ($it:expr, [ $t:tt ; $n:expr, $($r:tt)* ]) => {
        (0..$n).map(|_| _parse!($it, [$t; $($r)*])).collect::<Vec<_>>()
    };
    ($it:expr, chars) => {
        _parse!($it, String).chars().collect::<Vec<char>>()
    };
    ($it:expr, $t:ty) => {
        $it.next().unwrap().parse::<$t>().unwrap()
    };
}


macro_rules! array {
    ($t:tt ; $n:expr) => {
        vec![ $t ; $n ]
    };
    ($t:tt ; $n:expr, $($r:tt)*) => {
        vec![ array![$t; $($r)*]; $n ]
    };
}


use std::fmt::Write;

fn solve(buf: String) -> String {
    parse!{
        buf,
        n: usize,
        a: [usize; n]
    }

    let mut cnt = vec![0; n];
    for x in a {
        cnt[x-1] += 1;
    }
    cnt.sort();
    cnt.reverse();

    let mut ans = String::new();
    for k in 1..n+1 {
        let mut i = k-1;
        let mut acc = 0;
        while i < n {
            acc += cnt[i];
            i += k;
        }
        write!(ans, "{}\n", acc).unwrap();
    }
    ans
}


fn main() {
    let mut buf = String::new();
    stdin().read_to_string(&mut buf).unwrap();
    print!("{}", solve(buf));
}