You are given a sequence of integers $a_1, a_2, \dots, a_n$. You need to paint elements in colors, so that:   If we consider any color, all elements of this color must be divisible by the minimal element of this color.  The number of used colors must be minimized. 

For example, it's fine to paint elements $[40, 10, 60]$ in a single color, because they are all divisible by $10$. You can use any color an arbitrary amount of times (in particular, it is allowed to use a color only once). The elements painted in one color do not need to be consecutive.

For example, if $a=[6, 2, 3, 4, 12]$ then two colors are required: let's paint $6$, $3$ and $12$ in the first color ($6$, $3$ and $12$ are divisible by $3$) and paint $2$ and $4$ in the second color ($2$ and $4$ are divisible by $2$). For example, if $a=[10, 7, 15]$ then $3$ colors are required (we can simply paint each element in an unique color).


-----Input-----

The first line contains an integer $n$ ($1 \le n \le 100$), where $n$ is the length of the given sequence.

The second line contains $n$ integers $a_1, a_2, \dots, a_n$ ($1 \le a_i \le 100$). These numbers can contain duplicates.


-----Output-----

Print the minimal number of colors to paint all the given numbers in a valid way.


-----Examples-----
Input
6
10 2 3 5 4 2

Output
3

Input
4
100 100 100 100

Output
1

Input
8
7 6 5 4 3 2 2 3

Output
4



-----Note-----

In the first example, one possible way to paint the elements in $3$ colors is:

  paint in the first color the elements: $a_1=10$ and $a_4=5$,  paint in the second color the element $a_3=3$,  paint in the third color the elements: $a_2=2$, $a_5=4$ and $a_6=2$. 

In the second example, you can use one color to paint all the elements.

In the third example, one possible way to paint the elements in $4$ colors is:

  paint in the first color the elements: $a_4=4$, $a_6=2$ and $a_7=2$,  paint in the second color the elements: $a_2=6$, $a_5=3$ and $a_8=3$,  paint in the third color the element $a_3=5$,  paint in the fourth color the element $a_1=7$.

Difficulty: competition

Starter code:

Solutions:
n = int(input())
A = list(map(int, input().split()))
A.sort()
B = [0] * n
ans = 0
for i in range(n):
    if B[i] == 0:
        ans += 1
        B[i] = 1
        for j in range(n):
            if A[j] % A[i] == 0:
                B[j] = 1
print(ans)

n = int(input())
a = sorted(map(int , input().split()))
ans = 0
for i in range(n):
    f = 1
    for j in range(i):
        if a[i] % a[j] == 0:
            f = 0
            break
    ans += f
print(ans)

import sys

def read():
	return sys.stdin.readline()

def main():
	n = int(read())
	a = list(map(int, read().split()))
	a.sort()
	k = 0
	used = [0] * n
	for i in range(n):
		if used[i]:
			continue
		k += 1
		for j in range(i, n):
			if a[j] % a[i] == 0:
				used[j] = True
	print(k)
	
def __starting_point():
	main()

__starting_point()

n=int(input())
l1=list(map(int,input().split()))
ans=0
l1.sort()
visited=[0]*n
for i in range(n):
    if visited[i]==1:
        continue
    visited[i]=1
    ans+=1
    for j in range(i+1,n):
        if visited[j]==0 and l1[j]%l1[i]==0:
            visited[j]=1
print(ans)

def main():
    import sys
    input = sys.stdin.readline
    
    n = int(input())
    arr = list(map(int, input().split()))
    color = [0] * n
    arr.sort()
    
    ans = 0
    for i in range(n):
        if color[i]:
            continue
        ans += 1
        for j in range(i, n):
            if arr[j] % arr[i] == 0:
                color[j] = ans
    
    print(ans)
    
    return 0

main()


n = int(input())
A = list(map(int, input().split()))
A.sort()
ans = 1
for i in range(1, n):
  ok = False
  for j in range(i):
    if A[i] % A[j] == 0:
      ok = True
  if not ok:
    ans += 1
print(ans)


n = int(input())
a = sorted(list(map(int, input().split())))
s = []
for q in a:
    for q1 in s:
        if q % q1 == 0:
            break
    else:
        s.append(q)
print(len(s))


#!usr/bin/env python3
from collections import defaultdict,deque
from heapq import heappush, heappop
import sys
import math
import bisect
def LI(): return [int(x) for x in sys.stdin.readline().split()]
def I(): return int(sys.stdin.readline())
def LS():return [list(x) for x in sys.stdin.readline().split()]
def S():
    res = list(sys.stdin.readline())
    if res[-1] == "\n":
        return res[:-1]
    return res
def IR(n):
    return [I() for i in range(n)]
def LIR(n):
    return [LI() for i in range(n)]
def SR(n):
    return [S() for i in range(n)]
def LSR(n):
    return [LS() for i in range(n)]

sys.setrecursionlimit(1000000)
mod = 1000000007

#A
def A():
    n = I()
    a = LI()
    a.sort()
    f = [1]*n
    p = 0
    ans = 0
    while p < n:
        while p < n and not f[p]:
            p += 1
        if p == n:
            break
        ans += 1
        for i in range(n):
            if a[i]%a[p] == 0:
                f[i] = 0
    print(ans)
    return

#B
def B():

    return

#C
def C():

    return

#D
def D():

    return

#E
def E():

    return

#F
def F():

    return

#G
def G():

    return

#H
def H():

    return

#Solve
def __starting_point():
    A()

__starting_point()

from bisect import *
from collections import *
from itertools import *
import functools
import sys
import math
from decimal import *
from copy import *
from heapq import *
getcontext().prec = 30
MAX = sys.maxsize
MAXN = 10**5+10
MOD = 10**9+7
def isprime(n):
    n = abs(int(n))
    if n < 2:
        return False
    if n == 2: 
        return True    
    if not n & 1: 
        return False
    for x in range(3, int(n**0.5) + 1, 2):
        if n % x == 0:
            return False
    return True

def mhd(a,b):
    return abs(a[0]-b[0])+abs(b[1]-a[1])

def charIN(x= ' '):
    return(sys.stdin.readline().strip().split(x))

def arrIN(x = ' '):
    return list(map(int,sys.stdin.readline().strip().split(x)))

def eld(x,y):
    a = y[0]-x[0]
    b = x[1]-y[1]
    return (a*a+b*b)**0.5

def lgcd(a):
    g = a[0]
    for i in range(1,len(a)):
        g = math.gcd(g,a[i])
    return g

def ms(a):
    msf = -MAX
    meh = 0
    st = en = be = 0
    for i in range(len(a)):
        meh+=a[i]
        if msf<meh:
            msf = meh
            st = be
            en = i
        if meh<0:
            meh = 0
            be = i+1
    return msf,st,en

def ncr(n,r):
    num=den=1
    for i in range(r):
        num = (num*(n-i))%MOD
        den = (den*(i+1))%MOD

    return (num*(pow(den,MOD-2,MOD)))%MOD



def flush():
    return sys.stdout.flush()


def fac(n):
    ans = 1
    for i in range(1,n+1):
        ans*=i
        ans%=MOD
    return ans

'''*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*'''
n = int(input())
a = arrIN()
a.sort()
f = [1]*n
cnt = 0
for i in range(n):
    if f[i]:
        cnt+=1
        for j in range(i,n):
            if f[j] and a[j]%a[i]==0:
                f[j] = 0
        f[i] = 0
print(cnt)





n=int(input())
a=[int(i) for i in input().split()]
a.sort()
tot = 0
d={}
for i in range(len(a)):
    if a[i] not in d:
        tot+=1
        for j in range(i+1,len(a),1):
            if a[j]%a[i] == 0:
                d[a[j]]=1
print(tot)

n = int(input())

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

a.sort(reverse=True)

cnt = 0
while a:
    f = a.pop()
    rm = []
    for x in a:
        if x % f == 0:
            rm.append(x)
    for x in rm:
        a.remove(x)
    cnt += 1

print(cnt)


import sys
input = sys.stdin.readline

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

A.sort()

ANS=[0]*n

NOW=1
for i in range(n):
    if ANS[i]==0:
        ANS[i]=NOW

        for j in range(i,n):
            if A[j]%A[i]==0 and ANS[j]==0:
                ANS[j]=NOW

        NOW+=1

print(max(ANS))


# @author 

import sys

class APaintTheNumbers:
    def solve(self):
        n = int(input())
        a = [int(_) for _ in input().split()]
        a.sort()
        ans = 0
        done = [0] * n
        for i in range(n):
            if done[i]: continue
            ans += 1
            for j in range(i, n):
                if done[j]: continue
                if a[j] % a[i] == 0:
                    done[j] = 1

        print(ans)

solver = APaintTheNumbers()
input = sys.stdin.readline

solver.solve()


n = int(input())
l = sorted(map(int, input().split()))
seen = [False] * n
res = 0
for i in range(n):
    if seen[i]: continue
    res += 1
    for j in range(i, n):
        seen[j] |= l[j] % l[i] == 0
print(res)

n = int(input())
a = list(map(int, input().split()))

a = sorted(a)
ans = 0
b = [0] * n
for i in range(n):
    if b[i] == 0:
        ans += 1
        for j in range(i, n):
            if a[j] % a[i] == 0:
                b[j] = 1
print(ans)


def solve(n, a):
    a = sorted(a)
    col = [False for i in range(n)]
    count = 0
    for i in range(n):
        if not col[i]:
            count += 1
            col[i] = True
            for j in range(n):
                if a[j] % a[i] == 0:
                    col[j] = True
    return count
    
n = int(input())
a = list(map(int, input().split()))
print(solve(n, a))

n=int(input())
a=[int(x) for x in input().split()]
ans=0
while(min(a)<1001):
    ans+=1
    r=min(a)
    for i in range(len(a)):
        if a[i] != 1001:
            if a[i] % r == 0:
                a[i] = 1001
print(ans)

n = int(input())
a = list(sorted(map(int, input().split())))
ans = 0
divs = []
for x in a:
    if all(x % d != 0 for d in divs):
        ans += 1
        divs.append(x)
print(ans)


def calc(X):
    if len(X) == 0:
        return 0
    return calc([x for x in X if x % min(X)]) + 1
    
N = int(input())
print(calc([int(a) for a in input().split()]))




ans = 0
n = int(input())
new = [True] * 101
for a in sorted(map(int, input().split())):
    if new[a]:
        ans += 1
        for b in range(a, 101, a):
            new[b] = False  # Color all b's
print(ans)


import sys
input = sys.stdin.readline

n = int(input())
a = sorted(list(set(map(int, input().split()))))
n = len(a)
used = [0] * n
cnt = 0
for i in range(n):
    if not used[i]:
        used[i] = 1
        cnt += 1
        for j in range(i + 1, n):
            if a[j] % a[i] == 0:
                used[j] = 1
print(cnt)


n = int(input())
a = [int(i) for i in input().split()]
a.sort()
count = 0
for i in range(n):
    cur_c = a[i]
    if not cur_c:
        continue
    count += 1
    for j in range(i+1,n):
        if a[j]%cur_c == 0:
            a[j] = 0
print(count)

#JMD
#Nagendra Jha-4096

 
import sys
import math

#import fractions
#import numpy
 
###File Operations###
fileoperation=0
if(fileoperation):
    orig_stdout = sys.stdout
    orig_stdin = sys.stdin
    inputfile = open('W:/Competitive Programming/input.txt', 'r')
    outputfile = open('W:/Competitive Programming/output.txt', 'w')
    sys.stdin = inputfile
    sys.stdout = outputfile

###Defines...###
mod=1000000007
 
###FUF's...###
def nospace(l):
    ans=''.join(str(i) for i in l)
    return ans
 
 
 
##### Main ####
t=1
for tt in range(t):
    n=int(input())
    #n,k,s= map(int, sys.stdin.readline().split(' '))
    a=list(map(int,sys.stdin.readline().split(' ')))
    a.sort()

    i=0
    ans=0
    while i<len(a):
        if a[i]:
            ans+=1
            j=i+1
            while j<n:
                if(a[j]%a[i]==0):
                    a[j]=0
                j+=1
        i+=1
    print(ans)
    
    
#####File Operations#####
if(fileoperation):
    sys.stdout = orig_stdout
    sys.stdin = orig_stdin
    inputfile.close()
    outputfile.close()

n = int(input())
a = list(map(int, input().split()))
a.sort()
ans = 0
u = [0] * (n+1)
for i in range(n):
    if u[i] == 0:
        ans+=1
    for j in range(i, n):
        if a[j] % a[i] == 0:
            u[j] = 1
print(ans)