import sys

sys.setrecursionlimit(1000000000)

import math

from math import gcd

def lcm(a, b): return a * b // gcd(a, b)

from itertools import count, permutations, chain

from functools import lru_cache

from collections import deque, defaultdict

from pprint import pprint

ii = lambda: int(eval(input()))

mis = lambda: list(map(int, input().split()))

lmis = lambda: list(mis())

INF = float('inf')

N1097 = 10**9 + 7



def meg(f, ok, ng):

    while abs(ok-ng)>1:

        mid = (ok+ng)//2

        if f(mid):

            ok=mid

        else:

            ng=mid

    return ok



def get_inv(n, modp):

    return pow(n, modp-2, modp)



def factorials_list(n, modp):    # 10**6

    fs = [1]

    for i in range(1, n+1):

        fs.append(fs[-1] * i % modp)

    return fs



def invs_list(n, fs, modp):     # 10**6

    invs = [get_inv(fs[-1], modp)]

    for i in range(n, 1-1, -1):

        invs.append(invs[-1] * i % modp)

    invs.reverse()

    return invs



def comb(n, k, modp):

    num = 1

    for i in range(n, n-k, -1):

        num = num * i % modp

    den = 1

    for i in range(2, k+1):

        den = den * i % modp

    return num * get_inv(den, modp) % modp



def comb_from_list(n, k, modp, fs, invs):   

    return fs[n] * invs[n-k] * invs[k] % modp



#



class UnionFindEx:

    def __init__(self, size):

        #正なら根の番号、負ならグループサイズ

        self.roots = [-1] * size

    def getRootID(self, i):

        r = self.roots[i]

        if r < 0:   #負なら根

            return i

        else:

            r = self.getRootID(r)

            self.roots[i] = r

            return r

    def getGroupSize(self, i):

        return -self.roots[self.getRootID(i)]

    def connect(self, i, j):

        r1, r2 = self.getRootID(i), self.getRootID(j)

        if r1 == r2:

            return False

        if self.getGroupSize(r1) < self.getGroupSize(r2):

            r1, r2 = r2, r1

        self.roots[r1] += self.roots[r2]    #サイズ更新

        self.roots[r2] = r1

        return True



def get_primes(n):

    ps = [2]

    for i in range(3, n, 2):

        for p in ps:

            if i%p == 0:

                break

        else:

            ps.append(i)

    return ps





Yes = 'Yes'

No = 'No'





import numpy as np

def main():

    N=ii()

    A=lmis()

    A.sort()

    d = np.zeros(A[-1]+1, dtype=np.uint8)

    for i in range(N):

        a = A[i]

        pa = A[i-1]

        if a != pa:

            d[a::a] += 1

        else:

            d[a] += 1

    print((sum(d[a]==1 for a in A)))



main()



'''

方針

    1 ～ 10^6(Aの最大値) までの全ての数について、割り切れる数をカウント

    カウント == 1 ならば、他の数では割り切れないので、そのような数の個数が答え



工夫

    そのままの実装では、最悪ケース : 1 1 1 1 ... で、TLEする

    対策として、

        1. Aを昇順ソートする

        2. A[i]がA[i-1]と同じならば、2倍以上の倍数についてはスキップ

    とする

'''



import numpy as np



def main():

    N = int(eval(input()))

    A = list(map(int, input().split()))

    A.sort()

    d = np.zeros(A[-1]+1, dtype=np.uint64)  # 約数カウント。配列長さは、Aの最大値+1 で十分

    for i in range(N):

        a = A[i]

        a1 = A[i-1]

        if a != a1:     # 初出の数なら

            d[a::a] += 1    # aからaごとに+1する (範囲内の全ての倍数に、約数カウント+1)

        else:           # 重複なら

            d[a] += 1       # 自身のカウントを上げるだけで十分 (2倍以上はスキップ)

    print((np.count_nonzero(d[A] == 1)))  # Aのうち、約数カウントが1となったものの個数が答え



main()



import sys

sys.setrecursionlimit(1000000000)
import math
from math import gcd


def lcm(a, b):
    return a * b // gcd(a, b)


from itertools import count, permutations, chain
from functools import lru_cache
from collections import deque, defaultdict
from pprint import pprint

ii = lambda: int(eval(input()))
mis = lambda: list(map(int, input().split()))
lmis = lambda: list(mis())
INF = float("inf")
N1097 = 10**9 + 7


def meg(f, ok, ng):
    while abs(ok - ng) > 1:
        mid = (ok + ng) // 2
        if f(mid):
            ok = mid
        else:
            ng = mid
    return ok


def get_inv(n, modp):
    return pow(n, modp - 2, modp)


def factorials_list(n, modp):  # 10**6
    fs = [1]
    for i in range(1, n + 1):
        fs.append(fs[-1] * i % modp)
    return fs


def invs_list(n, fs, modp):  # 10**6
    invs = [get_inv(fs[-1], modp)]
    for i in range(n, 1 - 1, -1):
        invs.append(invs[-1] * i % modp)
    invs.reverse()
    return invs


def comb(n, k, modp):
    num = 1
    for i in range(n, n - k, -1):
        num = num * i % modp
    den = 1
    for i in range(2, k + 1):
        den = den * i % modp
    return num * get_inv(den, modp) % modp


def comb_from_list(n, k, modp, fs, invs):
    return fs[n] * invs[n - k] * invs[k] % modp


#
class UnionFindEx:
    def __init__(self, size):
        # 正なら根の番号、負ならグループサイズ
        self.roots = [-1] * size

    def getRootID(self, i):
        r = self.roots[i]
        if r < 0:  # 負なら根
            return i
        else:
            r = self.getRootID(r)
            self.roots[i] = r
            return r

    def getGroupSize(self, i):
        return -self.roots[self.getRootID(i)]

    def connect(self, i, j):
        r1, r2 = self.getRootID(i), self.getRootID(j)
        if r1 == r2:
            return False
        if self.getGroupSize(r1) < self.getGroupSize(r2):
            r1, r2 = r2, r1
        self.roots[r1] += self.roots[r2]  # サイズ更新
        self.roots[r2] = r1
        return True


def get_primes(n):
    ps = [2]
    for i in range(3, n, 2):
        for p in ps:
            if i % p == 0:
                break
        else:
            ps.append(i)
    return ps


Yes = "Yes"
No = "No"
import numpy as np


def main():
    N = ii()
    A = lmis()
    A.sort()
    d = np.zeros(A[-1] + 1, dtype=np.uint8)
    for i in range(N):
        a = A[i]
        pa = A[i - 1]
        if a != pa:
            d[a::a] += 1
        else:
            d[a] += 1
    print((sum(d[a] == 1 for a in A)))


main()

"""
方針
    1 ～ 10^6(Aの最大値) までの全ての数について、割り切れる数をカウント
    カウント == 1 ならば、他の数では割り切れないので、そのような数の個数が答え
工夫
    そのままの実装では、最悪ケース : 1 1 1 1 ... で、TLEする
    対策として、
        1. Aを昇順ソートする
        2. A[i]がA[i-1]と同じならば、2倍以上の倍数についてはスキップ
    とする
"""
import numpy as np


def main():
    N = int(eval(input()))
    A = list(map(int, input().split()))
    A.sort()
    d = np.zeros(A[-1] + 1, dtype=np.uint64)  # 約数カウント。配列長さは、Aの最大値+1 で十分
    for i in range(N):
        a = A[i]
        a1 = A[i - 1]
        if a != a1:  # 初出の数なら
            d[a::a] += 1  # aからaごとに+1する (範囲内の全ての倍数に、約数カウント+1)
        else:  # 重複なら
            d[a] += 1  # 自身のカウントを上げるだけで十分 (2倍以上はスキップ)
    print((np.count_nonzero(d[A] == 1)))  # Aのうち、約数カウントが1となったものの個数が答え


main()

-import sys - -sys.setrecursionlimit(1000000000) -import math -from math import gcd - - -def lcm(a, b): -    return a * b // gcd(a, b) - - -from itertools import count, permutations, chain -from functools import lru_cache -from collections import deque, defaultdict -from pprint import pprint - -ii = lambda: int(eval(input())) -mis = lambda: list(map(int, input().split())) -lmis = lambda: list(mis()) -INF = float("inf") -N1097 = 10**9 + 7 - - -def meg(f, ok, ng): -    while abs(ok - ng) > 1: -        mid = (ok + ng) // 2 -        if f(mid): -            ok = mid -        else: -            ng = mid -    return ok - - -def get_inv(n, modp): -    return pow(n, modp - 2, modp) - - -def factorials_list(n, modp):  # 10**6 -    fs = [1] -    for i in range(1, n + 1): -        fs.append(fs[-1] * i % modp) -    return fs - - -def invs_list(n, fs, modp):  # 10**6 -    invs = [get_inv(fs[-1], modp)] -    for i in range(n, 1 - 1, -1): -        invs.append(invs[-1] * i % modp) -    invs.reverse() -    return invs - - -def comb(n, k, modp): -    num = 1 -    for i in range(n, n - k, -1): -        num = num * i % modp -    den = 1 -    for i in range(2, k + 1): -        den = den * i % modp -    return num * get_inv(den, modp) % modp - - -def comb_from_list(n, k, modp, fs, invs): -    return fs[n] * invs[n - k] * invs[k] % modp - - -# -class UnionFindEx: -    def __init__(self, size): -        # 正なら根の番号、負ならグループサイズ -        self.roots = [-1] * size - -    def getRootID(self, i): -        r = self.roots[i] -        if r < 0:  # 負なら根 -            return i -        else: -            r = self.getRootID(r) -            self.roots[i] = r -            return r - -    def getGroupSize(self, i): -        return -self.roots[self.getRootID(i)] - -    def connect(self, i, j): -        r1, r2 = self.getRootID(i), self.getRootID(j) -        if r1 == r2: -            return False -        if self.getGroupSize(r1) < self.getGroupSize(r2): -            r1, r2 = r2, r1 -        self.roots[r1] += self.roots[r2]  # サイズ更新 -        self.roots[r2] = r1 -        return True - - -def get_primes(n): -    ps = [2] -    for i in range(3, n, 2): -        for p in ps: -            if i % p == 0: -                break -        else: -            ps.append(i) -    return ps - - -Yes = "Yes" -No = "No" +""" +方針 +    1 ～ 10^6(Aの最大値) までの全ての数について、割り切れる数をカウント +    カウント == 1 ならば、他の数では割り切れないので、そのような数の個数が答え +工夫 +    そのままの実装では、最悪ケース : 1 1 1 1 ... で、TLEする +    対策として、 +        1. Aを昇順ソートする +        2. A[i]がA[i-1]と同じならば、2倍以上の倍数についてはスキップ +    とする +""" -    N = ii() -    A = lmis() +    N = int(eval(input())) +    A = list(map(int, input().split())) -    d = np.zeros(A[-1] + 1, dtype=np.uint8) +    d = np.zeros(A[-1] + 1, dtype=np.uint64)  # 約数カウント。配列長さは、Aの最大値+1 で十分 -        pa = A[i - 1] -        if a != pa: -            d[a::a] += 1 -        else: -            d[a] += 1 -    print((sum(d[a] == 1 for a in A))) +        a1 = A[i - 1] +        if a != a1:  # 初出の数なら +            d[a::a] += 1  # aからaごとに+1する (範囲内の全ての倍数に、約数カウント+1) +        else:  # 重複なら +            d[a] += 1  # 自身のカウントを上げるだけで十分 (2倍以上はスキップ) +    print((np.count_nonzero(d[A] == 1)))  # Aのうち、約数カウントが1となったものの個数が答え