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 Haskell (GHC 8.8.3) (judge verdict: Runtime Error)

{-# LANGUAGE
    BangPatterns, MultiWayIf, TupleSections, TypeApplications #-}
{-# OPTIONS_GHC -O2 #-}

import Control.Arrow
import Control.Concurrent
import Control.Monad
import qualified Data.ByteString.Builder as B
import qualified Data.ByteString.Char8 as C
import Data.Bits
import Data.Complex
import Data.Char
import Data.Function
import Data.Function.HT
import qualified Data.IntMap.Strict as IM
import qualified Data.IntSet as IS
import Data.List
import Data.Monoid
import Data.Ord
import qualified Data.Sequence as Sq
import Data.Vector.Algorithms.Search
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as VM
import qualified Data.Vector.Unboxed as U
import qualified Data.Vector.Unboxed.Mutable as UM
import Debug.Trace
import System.IO

r :: Int -> IO (U.Vector Int)
r n = U.unfoldrN n (C.readInt . C.dropWhile (==' ')) <$> C.getLine

r' :: IO [Int]
r'  =   unfoldr    (C.readInt . C.dropWhile (==' ')) <$> C.getLine

main = do
    n <- readLn :: IO Int
    x <- C.getLine
    let bitsSet = C.count '1' x
        xLow = bsToModInt (bitsSet - 1) x
        xHi  = bsToModInt (bitsSet + 1) x

    arr <- UM.replicate (2*10^5 + 1) (-1 :: Int)
    UM.write arr 0 0
    forM_ [1..2*10^5] (\i -> do
            rc <- UM.read arr (step i)
            UM.write arr i (rc+1)
        )

    forM_ [0..n-1] (\i -> let memo = if C.index x i == '1'
                                    then minusMod
                                        (bitsSet - 1)
                                        xLow
                                        (powMod (bitsSet - 1) 2 (n-i-1))
                                    else plusMod
                                        (bitsSet + 1)
                                        xHi
                                        (powMod (bitsSet + 1) 2 (n-i-1))
                in do
                    rc <- UM.read arr memo
                    print (rc+1)
        )


step n = n `rem` (popCount n)

bsToModInt :: Int -> C.ByteString -> Int
bsToModInt md bs = let l = C.length bs
    in foldr1 (plusMod md) $
        map (\flipPos -> if C.index bs (l-flipPos-1) == '1'
                then powMod md 2 flipPos else 0) [l-1,l-2..0]


powMod :: Int -> Int -> Int -> Int
powMod mdl b e = powAux (b `rem` mdl) e 1 `mod` mdl
    where 
        powAux _ 0 !ac = ac
        powAux b e !ac = powAux (b*b `rem` mdl) (e `quot` 2)
            (if odd e then b*ac `rem` mdl else ac)

plusMod  mdl a b = (a + b) `rem` mdl
minusMod mdl a b = (a - b) `mod` mdl