Problem:
Score : 400 points

Problem Statement

Let \mathrm{popcount}(n) be the number of 1s in the binary representation of n.
For example, \mathrm{popcount}(3) = 2, \mathrm{popcount}(7) = 3, and \mathrm{popcount}(0) = 0.

Let f(n) be the number of times the following operation will be done when we repeat it until n becomes 0: "replace n with the remainder when n is divided by \mathrm{popcount}(n)." (It can be proved that, under the constraints of this problem, n always becomes 0 after a finite number of operations.)

For example, when n=7, it becomes 0 after two operations, as follows:

\mathrm{popcount}(7)=3, so we divide 7 by 3 and replace it with the remainder, 1.

\mathrm{popcount}(1)=1, so we divide 1 by 1 and replace it with the remainder, 0.

You are given an integer X with N digits in binary.
For each integer i such that 1 \leq i \leq N, let X_i be what X becomes when the i-th bit from the top is inverted.
Find f(X_1), f(X_2), \ldots, f(X_N).

Constraints

1 \leq N \leq 2 \times 10^5

X is an integer with N digits in binary, possibly with leading zeros.

Input

Input is given from Standard Input in the following format:

N
X

Output

Print N lines. The i-th line should contain the value f(X_i).

Sample Input 1

3
011

Sample Output 1

2
1
1

X_1 = 7, which will change as follows: 7 \rightarrow 1 \rightarrow 0. Thus, f(7) = 2.

X_2 = 1, which will change as follows: 1 \rightarrow 0. Thus, f(1) = 1.

X_3 = 2, which will change as follows: 2 \rightarrow 0. Thus, f(2) = 1.

Sample Input 2

23
00110111001011011001110

Sample Output 2

2
1
2
2
1
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
2
1
3

Solution in Rust (1.42.0) (judge verdict: Accepted)

use proconio::input;
use proconio::marker::Chars;
use std::cmp::{max, min};
const alpha: [char; 26] = [
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's',
    't', 'u', 'v', 'w', 'x', 'y', 'z',
];

const Alpha: [char; 26] = [
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S',
    'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
];
fn main() {
    input!(N: usize);
    input!(x: Chars);
    let X: Vec<usize> = x.iter().map(|&c| c.to_digit(2).unwrap() as usize).collect();
    let mut ans = vec![0; N];
    // 最初の割り算を行う
    let pc: usize = X.iter().sum();
    // let mut base = 0;
    // for i in 0..N {
    //     base *= 2;
    //     base += X[i];
    //     base %= pc;
    // }

    // 2回目移行の割り算は再帰関数に任せる！

    for b in 0..2 {
        let mut npc = pc;
        if b == 1 && pc <= 1 {
            continue;
        }
        if b == 0 {
            npc += 1;
        } else {
            npc -= 1;
        }

        let mut base = 0;
        for i in 0..N {
            base = (2 * base) % npc;
            base += X[i];
        }

        let mut k = 1;
        for i in (0..N).rev() {
            if X[i] == b {
                let mut r = base;
                if b == 0 {
                    r = (r + k) % npc;
                } else {
                    r = (r + npc - k) % npc;
                }
                ans[i] = f(r) + 1;
            }
            k = (2 * k) % npc;
        }
    }

    for i in 0..N {
        println!("{}", ans[i]);
    }
}

fn popcount(n: usize) -> usize {
    let mut ret = 0;
    for i in 0..40 {
        if (1 << i) & n != 0 {
            ret += 1;
        }
    }
    ret
}

fn f(mut n: usize) -> usize {
    let mut ret = 0;
    while n > 0 {
        let t = popcount(n);
        n %= t;
        ret += 1;
    }
    ret
}

fn reverse(x: usize, i: usize, n: usize) -> usize {
    let mask = 1 << (n - i - 1);
    if x & mask == 0 {
        return x + mask;
    }
    x - mask
}

fn to_usize(cs: Vec<char>) -> usize {
    let n = cs.len();
    let mut ret = 0;
    for i in 0..n {
        if cs[i] == '1' {
            ret += 1 << (n - i - 1);
        }
    }
    ret
}

fn calc(X: usize, i: usize, N: usize) -> usize {
    let rev = reverse(X, i, N);
    f(rev)
}