-- 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''
