Problem:
Score : 400 points

Problem Statement

Given is a number sequence A of length N.

Find the number of integers i \left(1 \leq i \leq N\right) with the following property:

For every integer j \left(1 \leq j \leq N\right) such that i \neq j , A_j does not divide A_i.

Constraints

All values in input are integers.

1 \leq N \leq 2 \times 10^5

1 \leq A_i \leq 10^6

Input

Input is given from Standard Input in the following format:

N
A_1 A_2 \cdots A_N

Output

Print the answer.

Sample Input 1

5
24 11 8 3 16

Sample Output 1

3

The integers with the property are 2, 3, and 4.

Sample Input 2

4
5 5 5 5

Sample Output 2

0

Note that there can be multiple equal numbers.

Sample Input 3

10
33 18 45 28 8 19 89 86 2 4

Sample Output 3

5

Solution in Haskell (GHC 8.8.3) (judge verdict: Wrong Answer)

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)