{-# LANGUAGE BangPatterns #-}
import Control.Monad
import Data.Maybe
import Debug.Trace
import Data.List
import qualified Data.Map.Strict as Map
import qualified Data.IntMap.Strict as IntMap
import qualified Data.Set as Set
import qualified Data.IntSet as IntSet
import Data.Functor
-- import Data.Array
import Data.Array.Unboxed
import Control.Monad.ST
import Data.Array.ST

main :: IO ()
main = do
  n <- readLn :: IO Int
  as <- map read . words <$> getLine :: IO [Int]
  solve n as


solve n as = go (IntMap.empty) . reverse $ zip as [1..n]
  where
    go mp [] = do
      let m = sum . IntMap.elems $ mp
      print m
      if m == 0 
        then return ()
        else putStrLn . unwords . map show $ replicate m 1
    go mp (an:as)
      | IntMap.member i mp = if mp IntMap.! i == a
          then go mp as
          else go newmp as        
      | otherwise = if a `mod` 2 == 0
          then go mp as
          else go newmp as
        where
          
          (a, i) = an
          newmp = foldl' 
            (\m b -> if IntMap.member b m 
                then IntMap.adjust (\x -> (x + 1)) b m
                else IntMap.insert b 1 m)
            mp $ factors i
        -- divs = factors i
        -- newmp = IntMap.fromListWith (\x y -> (x + y) `mod` 2 ) 
        --   $ zip divs (repeat 1)


-- primeFactors :: Integer -> [Integer]
primeFactors n | n < 2 = []
primeFactors n = go n [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293,
  307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601,
  607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009]
   where
     go !n pps@(p:ps)
       | n < p*p   = [n]
       | r > 0     = go n ps
       | otherwise = p:go q pps
      where
        (q,r) = quotRem n p
     go n [] = [n]

factors = Map.foldrWithKey (\k v acc -> products (powers k v) acc) [1] . toCountMap . primeFactors

-- powers :: (Integral a) => a -> a -> [a]
powers n m = [ n^i | i <- [0..m]]

products :: (Num a) => [a] -> [a] -> [a]
products xs ys = [ x*y | x <- xs, y <- ys]

toCountMap :: (Ord k, Integral a) => [k] -> Map.Map k a
toCountMap xs = Map.fromListWith (+) $ zip xs (repeat 1)
