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: Wrong Answer)

-- TLE / RE

import Data.Array
import qualified Data.ByteString.Char8 as BS
import Data.Char
import Data.List
import Data.Maybe

readInt = fst . fromJust . BS.readInt

readString = map BS.unpack . BS.words

getInt = readInt <$> BS.getLine

getString = readString <$> BS.getLine

dec2bin x
  | x <= 1 = (show (x `mod` 2))
  | otherwise = (dec2bin (x `div` 2)) ++ (show (x `mod` 2))

bin2dec lis = truncate (inner_bin2dec (reverse lis) 0)

inner_bin2dec [x] n = (read [x]) * 2 ** n
inner_bin2dec (x : rest) n =
  (read [x]) * 2 ** n
    + (inner_bin2dec rest (n + 1))

popcount b = length (filter (\c -> c == '1') b)

solve' :: String -> Int -> Int
solve' b i = do
  let p = popcount b
  let i' = i + 1
  let d = bin2dec b
  let r = d `mod` p
  if r /= 0
    then do
      let b' = dec2bin r
      solve' b' i'
    else i'

solve :: Int -> Array Int Char -> Int -> Int -> Int -> Int -> Int -> Int
solve bit x n p0 p1 s0 s1 = do
  let c = x ! bit
  let c' = if c == '0' then '1' else '0'
  let x' = x // [(bit, c')]
  let x'' = elems x'
  let p = popcount x''
  if p == 0
    then 0
    else do
      let d = if c == '0' then (2 ^ (n - bit) `mod` p0 + s0) `mod` p0 else (- 2 ^ (n - bit) `mod` p1 + s1) `mod` p1
      let x''' = dec2bin d
      if d == 0
        then 1
        else solve' x''' 1

main = do
  n <- getInt
  [x] <- getString
  let ppc = popcount x
  let p0 = ppc + 1
  let p1 = ppc - 1
  let d = bin2dec x
  let s0 = d `mod` p0
  let s1 = d `mod` p1
  let x' = listArray (1, n) x
  let bits = [1 .. n]
  let x'' = map (\bit -> solve bit x' n p0 p1 s0 s1) bits
  mapM_ print x''