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 Kotlin (1.3.71) (judge verdict: Runtime Error)

fun main() {
    val n = nextInt()
    val x = next().map { (it - 48).toInt() }.toIntArray()
    val popcount = x.filter { it == 1 }.size
    val less = remInt(x, popcount - 1)
    val greater = remInt(x, popcount + 1)
    val lessRems = sizedArray(n, 1.rem(popcount.minus(1)))
    val greaterRems = sizedArray(n, 1.rem(popcount.plus(1)))
    (n.minus(2) downTo 0).forEach { index ->
        lessRems[index] = lessRems[index + 1].times(2).rem(popcount.minus(1))
        greaterRems[index] = greaterRems[index + 1].times(2).rem(popcount.plus(1))
    }

    (0 until n).forEach { index ->
        var count = 1
        var (pc, x2) = if (x[index] == 0) {
            val pc = popcount.plus(1)
            pc to Integer.toBinaryString(greater.plus(greaterRems[index]).rem(pc)).map { (it - 48).toInt() }
                .toIntArray()
        } else {
            val pc = popcount.minus(1)
            pc to Integer.toBinaryString(less.minus(lessRems[index]).plus(pc).rem(pc)).map { (it - 48).toInt() }
                .toIntArray()
        }
        while (x2.any { value -> value == 1 }) {
            pc = x2.count { it == 1 }
            x2 = rem(x2, pc)
            count += 1
        }
        println(count)
    }
}

private fun rem(values: IntArray, mod: Int): IntArray {
    var operand = 0
    values.forEach { value ->
        operand = operand.shl(1).plus(value).rem(mod)
    }
    return Integer.toBinaryString(operand).map { (it - 48).toInt() }.toIntArray()
}

private fun remInt(values: IntArray, mod: Int): Int {
    var operand = 0
    values.forEach { value ->
        operand = operand.shl(1).plus(value).rem(mod)
    }
    return operand
}

// # Utils
// ## Input
fun next() = readLine()!!
fun nextInt() = next().toInt()
fun nextLong() = next().toLong()
fun nextDouble() = next().toDouble()
fun nextList() = next().split(" ")
fun nextIntList() = next().split(" ").map(String::toInt)
fun nextLongList() = next().split(" ").map(String::toLong)
fun nextDoubleList() = next().split(" ").map(String::toDouble)

// ## Array
inline fun <reified T> sizedArray(size: Int, default: T) = Array(size) { default }

// ## mod^-1
//    [NOTE] CANNOT use this for 0, mod, 2mod, 3mod ...(return wrong value)
fun modinv(num: Long, mod: Long): Long {
    var a = num
    var b = mod
    var u = 1L
    var v = 0L
    while (b > 0) {
        val t = a.div(b)
        a -= t * b
        a = b.also { b = a } // swap a and b
        u -= t * v
        u = v.also { v = u } // swap u and v
    }
    u %= mod
    if (u < 0) u += mod
    return u
}