//////////////////////////////////////
////   Author: ABHINASH GIRI      ////
/////////////////////////////////////

#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")
#include<bits/stdc++.h>
using namespace std;
#define fast ios_base::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr)
#define PI (2*acos(0.0))
#define setbits(x)      __builtin_popcountll(x)
#define zrobits(x)      __builtin_ctzll(x)
#define pos_rt_stbt(x)   (__builtin_ffsll(x))   // return position of rightmost set bit ( 1 indexing ) pos_rt_stbt(10) = 2 ( 1010 )
#define ps(x,y)         fixed<<setprecision(y)<<x
#define w(x)            int t; cin>>t; while(t--)
#define nl "\n"
#define all(v) (v).begin(),(v).end()
#define clr(v) memset(v,0,sizeof(v));
#define sqr(x) ((x) * (x))
typedef long long ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<long long int> vll;
typedef vector<unsigned long long int> vull;
typedef vector<string> vs;
typedef vector<double> vd;
typedef pair<ll, ll> pll;
typedef vector<pair<ll, ll>> vpll;
typedef vector<pair<string, string>> vpss;

//***********************************************************************************************

//CONSTANTS
const long long int inf = 1e18;
const long long int ninf = -1e18;
const long long int mod = 1000000007;
const long long int MOD =  998244353;
//***********************************************************************************************

//Debug code

#define debug1(x)                   cout<<#x<<"="<<x<<'\n'
#define debug2(x,y)                 cout<<#x<<"="<<x<<","<<#y<<"="<<y<<'\n'
#define debug3(x,y,z)               cout<<#x<<"="<<x<<","<<#y<<"="<<y<<","<<#z<<"="<<z<<'\n'

//***********************************************************************************************
// Printing
#define ptvs(v) for(auto &item :v) cout<<item<<" ";
#define ptp(v) for(auto &item :v) cout<<item.first<<" "<<item.second<<"\n"
#define ptv(v) for(auto &item :v) cout<<item<<"\n"
#define ptb(ans) cout<<(ans?"YES\n":"NO\n")
#define pt(x) cout<<((x))<<"\n";
#define pts(x,y) cout<<x<<" "<<y<<"\n";

//Take input
#define get1(a) cin>>a
#define get2(a,b) cin>>a>>b
#define get3(a,b,c) cin>>a>>b>>c
#define cinll(i) ll i=0;cin>>i
#define cins(s) string s;cin>>s
#define cinvll(v,start,end) vll v(end+1);for(auto i=start;i<=end;i++) {cin>>v[i];}

//***********************************************************************************************
//Sorting Comparators

// sorts in ascending order on first and on second ( if first equals)
template <typename T>
bool asc(pair<T, T>&a, pair<T, T>&b)
{
    if (a.first == b.first)
    {return a.second < b.second;}
    return a.first < b.first;
}

// sorts in descending order on first and on second ( if first equals)
template <typename T>
bool desc(pair<T, T>&a, pair<T, T>&b)
{
    if (a.first == b.first)
    {return a.second > b.second;}
    return a.first > b.first;
}

//***********************************************************************************************

// Fast Exponentiation power(a,b) ==> a to the power b
template <typename T>
T  power(T  a, T  b) {
    if (b == 0)
        return 1;
    if (b == 1)
        return a;
    else {
        T  res = (power(a, b / 2));
        if (b % 2)
        {
            return (res * res * a);
        }
        else
        {return res * res;}
    }
}

// Fast Modular Exponentiation  power(a,b,m) ==> (a to the power b) modulo m
template <typename T>
T  power(T  a, T  b, T modulo) {
    if (b == 0)
        return 1;
    if (b == 1)
        return a;
    else {
        T  res = (power(a, b / 2, modulo) % modulo);
        if (b % 2)
        {
            return ((((res % modulo) * (res % modulo)) % modulo) * (a % modulo)) % modulo;
        }
        else
        {return ((res % modulo) * (res % modulo)) % modulo;}
    }
}

// G C D
template <typename T>
T  gcd(T  a, T  b) {
    if (b == 0)
        return a;
    return gcd(b, a % b);
}

// L C M
template <typename T>
T lcm(T p, T q)
{
    return (p * q) / gcd<T>(p, q);
}
//Prime factorisation
template <typename T>
void primefactorise(T n, vector<T>&vec)
{
    while (n % 2 == 0) {
        vec.emplace_back(2);
        n = n / 2;
    }
    // n must be odd at this point.  So we can skip
    // one element (Note i = i +2)
    for (int i = 3; i <= sqrt(n); i = i + 2) {
        // While i divides n, print i and divide n
        while (n % i == 0)
        {
            vec.emplace_back(i);
            n = n / i;
        }
    }
    // This condition is to handle the case when n
    // is a prime number greater than 2
    if (n > 2)
    {
        vec.emplace_back(n);
    }
}

// All factors of a number in O(sqrt(n))
template <typename T>
void all_factor(T n, vector<T>&vec)
{
    for (auto i = 1; i <= sqrt(n) ; ++i) {
        if (n % i == 0)
        {
//          Factors occurs in pairs
            vec.emplace_back(i);
            if(i!=(n/i))
            {
                vec.emplace_back(n / i);
            }

        }
    }
}

ll mulmod(ll a, ll b, ll c)
{

    if (b == 0)
    {

        return 0;
    }
    // Divide the problem into 2 parts
    ll s = mulmod(a, b / 2, c);

    // If b is odd, return
    // (a+(2*a)*((b-1)/2))%c
    if (b % 2 == 1)
    {   ll p = (a % c + 2 * (s % c)) % c;
        //cout<<" returned "<<p<<endl;
        return p;
    }
        // If b is even, return
        // ((2*a)*(b/2))%c
    else
    {   ll  p = (2 * (s % c)) % c;
        //cout<<" returned "<<p<<endl;
        return p ;
    }
}

ll mod_inv(ll a) {    return (power<ll>(a, mod - 2, mod)) % mod;    }

void factorial(ll n, vll fact)
{
    fact.resize(n + 1, 1);
    fact[0] = 1;
    fact[1] = 1;
    for (int i = 2; i <= n ; ++i)
    {
        fact[i] = ((fact[i - 1] % mod) * (i % mod)) % mod;
    }
}

int main() {
    std::chrono::time_point<std::chrono::high_resolution_clock> start_timer, end_timer;
    start_timer = std::chrono::high_resolution_clock::now();
    bool show_time = false;  //  change it to true when needed;
    /* Building Block */
    fast;
    cinll(n);
    cinvll(v,1,n);
    ll a=0;
    sort(all(v));
    map<ll,ll>mp;
    for (ll i = 1; i <=n ; ++i) {
        mp[v[i]]++;
    }
    vll p(v[n]+1,0);

    for (ll i = 1; i <=n ; ++i) {
        if(p[v[i]])
        {
            continue;
        }
        if(mp[v[i]]==1 and p[v[i]]==0)
        {
            a++;
        }
        for (ll j =v[i]; j <=v[n] ;j+=v[i]) {
            p[j]=1;
            //pt(j);
        }
    }
    pt(a);
    end_timer = std::chrono::high_resolution_clock::now();
    ll elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_timer - start_timer).count();
    if (show_time)
    {cout << "\nElapsed Time: " << elapsed_time << "ms\n";}

    return 0;
}










Measured memory_bytes: 25040