{-# LANGUAGE PartialTypeSignatures #-}
{-# LANGUAGE BangPatterns #-}
{-# LANGUAGE MultiWayIf #-}
module Main (main) where
-- module ABC.ABC170.D where

import qualified Data.ByteString.Char8 as C8
import qualified Data.Char as C
import qualified Data.List as L
import Data.Vector (Vector)
import qualified Data.Vector as V
import qualified Data.Vector.Mutable as MV
import qualified Data.Vector.Generic.Mutable as MGV
import qualified Data.Vector.Algorithms.Merge as V
import Control.Monad.ST
import Control.Monad

main :: IO ()
main = do
  [n] <- readInts
  vec <- readIntsV
  -- mvec <- V.thaw vec
  -- V.sort mvec
  output . solve n $ vec

solve :: Int -> Vector Int -> Int
solve n vec = V.sum $ runST $ do
  mvec <- V.thaw vec
  V.sort mvec
  forM_ [0..n-1] $ \i -> do
    x <- MV.unsafeRead mvec i
    when (x > 0) $ do
      MV.write mvec i 1
      forM_ [i+1..n-1] $ \j -> do
        y <- MV.unsafeRead mvec j
        when (x==y) $ MV.write mvec i 0
        when (y `mod` x == 0) $
          MV.write mvec j 0
      -- when (MV.length mvec == 1) $
      --   MV.write mvec 0 1
  V.unsafeFreeze mvec
  -- | otherwise = let (c1,vec1) = go False (V.head vec) (V.tail vec) in fromEnum c1 + solve vec1
  -- where
  --   go isSeq a v
  --     | V.null v = if isSeq then (0,V.empty) else (1,V.empty)
  --     | otherwise =
  --         let b = V.head v
  --             bs = V.tail v
  --         in if | a==1 && b==1 -> (0,V.empty)
  --               | a==1 -> (1,V.empty)
  --               | (b `mod` a) == 0 -> let (c,l) = go (a==b) a bs in (c,l)
  --               | otherwise -> let (c,l) = go isSeq a bs in (c,b `V.cons` l) -- ここが問題

output :: Int -> IO ()
output = print

-- utils
readInts :: IO [Int]
readInts = L.unfoldr (C8.readInt . C8.dropWhile C.isSpace) <$> C8.getLine

readIntsV :: IO (Vector Int)
readIntsV = V.unfoldr (C8.readInt . C8.dropWhile C.isSpace) <$> C8.getLine

