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: Time Limit Exceeded)

import qualified Data.Text as T
import qualified Data.Text.IO as T
import qualified Data.Text.Read as T
import Data.List (sort, group)
import Data.Heap (Heap)
import qualified Data.Heap as H
import Data.Maybe (fromJust)
import Data.Bool (bool)

main :: IO ()
main = do
  let
    unsafeNext :: Heap (H.Entry Int [Int]) -> (Int, Heap (H.Entry Int [Int]))
    unsafeNext = f . fromJust . H.viewMin
      where
        f :: (H.Entry Int [Int], Heap (H.Entry Int [Int])) -> (Int, Heap (H.Entry Int [Int]))
        f (H.Entry x (x' : xs), h) = (x, H.insert (H.Entry x' xs) h)
    unsafeDropWhile :: (Int -> Bool) -> Heap (H.Entry Int [Int]) -> Heap (H.Entry Int [Int])
    unsafeDropWhile p = f
      where
        f :: Heap (H.Entry Int [Int]) -> Heap (H.Entry Int [Int])
        f h | p x       = f h'
            | otherwise = h
          where
            (x, h') = unsafeNext h :: (Int, Heap (H.Entry Int [Int]))
    f :: [(Int, Int)] -> (Int, Heap (H.Entry Int [Int]))
    f = foldl step (0, H.empty)
      where
        step :: (Int, Heap (H.Entry Int [Int])) -> (Int, Int) -> (Int, Heap (H.Entry Int [Int]))
        step (_, h) (x, l) | H.null h  = (bool l 0 (l == 1), H.insert (H.Entry (2 * x) (map (x *) [3..])) h)
        step (k, h) (x, l) | x < y     = (k + bool l 0 (l == 1), H.insert (H.Entry (2 * x) (map (x *) [3..])) h')
                           | otherwise = (k + l, h'')
          where
            h' = unsafeDropWhile (< x) h :: Heap (H.Entry Int [Int])
            (y, h'') = unsafeNext h' :: (Int, Heap (H.Entry Int [Int]))
  n <- unsafeTextToInt <$> T.getLine :: IO Int
  as <- map unsafeTextToInt . T.words <$> T.getLine :: IO [Int]
  print . (n -) . fst . f . map ((,) <$> head <*> length) . group . sort $ as

unsafeTextToInt :: T.Text -> Int
unsafeTextToInt s = case T.signed T.decimal s of
  Right (n, _) -> n
{-# INLINE unsafeTextToInt #-}