import Control.Monad
import qualified Data.ByteString.Char8 as BS
import Data.List
import Data.Maybe
import Data.Ord
import qualified Data.Set as Set
import qualified Data.Vector.Unboxed.Mutable as VUM

readInt = fst . fromJust . BS.readInt
readIntList = map readInt . BS.words

getInt = readInt <$> BS.getLine
getIntList = readIntList <$> BS.getLine

ordNub :: (Ord a) => [a] -> [a]
ordNub l = go Set.empty l
  where
    go _ [] = []
    go s (x : xs) =
      if x `Set.member` s
        then go s xs
        else x : go (Set.insert x s) xs

fill table (c : cs) = do
  VUM.write table c False
  when (cs /= []) $ fill table cs

fillVector table (a : as) n = do
  let diva = n `div` a
  if  (diva >= 2)
    then do
      let cs = map (\x -> x * a) [2 .. diva]
      fill table cs
      when (as /= []) $ fillVector table as n
    else do
      when (as /= []) $ fillVector table as n

seek table (a : as) xs = do
  if as == []
    then return xs
    else do
      point <- VUM.read table a
      let xs' = if point == True then a : xs else xs
      seek table as xs'

main = do
  n <- getInt
  as <- getIntList
  let as' = ordNub as
  let ds = as \\ as'
  if length as' == 0
    then print 0
    else do
      let m = maximum as'
      table <- VUM.replicate (m + 1) True :: IO (VUM.IOVector Bool)
      fillVector table as' m
      rs <- seek table as' []
      print $ length (filter (\x -> x `notElem` ds) rs)
