// Original C++ solution (slower):
// C

#ifndef _GLIBCXX_NO_ASSERT

#include <cassert>

#endif

#include <cctype>

#include <cerrno>

#include <cfloat>

#include <ciso646>

#include <climits>

#include <clocale>

#include <cmath>

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>



#if __cplusplus >= 201103L

#include <ccomplex>

#include <cfenv>

#include <cinttypes>

// #include <cstdalign>

#include <cstdbool>

#include <cstdint>

#include <ctgmath>

#include <cwchar>

#include <cwctype>

#endif



// C++

#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <istream>

#include <iterator>

#include <limits>

#include <list>

#include <locale>

#include <map>

#include <memory>

#include <new>

#include <numeric>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <typeinfo>

#include <utility>

#include <valarray>

#include <vector>



#if __cplusplus >= 201103L

#include <array>

#include <atomic>

#include <chrono>

#include <condition_variable>

#include <forward_list>

#include <future>

#include <initializer_list>

#include <mutex>

#include <random>

#include <ratio>

#include <regex>

#include <scoped_allocator>

#include <system_error>

#include <thread>

#include <tuple>

#include <typeindex>

#include <type_traits>

#include <unordered_map>

#include <unordered_set>

#endif



using namespace std;

typedef long long int ll;

typedef unsigned long long ull;

typedef long double ld;

#define REP(i,n) for(ll i=0; i<(n); i++)

#define REPR(i, n) for(ll i = n;i >= 0;i--)

#define FOR(i, m, n) for(ll i = m;i < n;i++)

#define ALL(n) begin(n),end(n)

#define IN(a, x, b) (a<=x && x<b)

#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);

template<class T> inline T CHMAX(T & a, const T b) { return a = (a < b) ? b : a; }

template<class T> inline T CHMIN(T & a, const T b) { return a = (a > b) ? b : a; }



const long double EPS = 1e-10;

const long long INF = 1e18;

const long double PI = acos(-1.0L);

const long long MOD = 1000000007;





int main(void){

    ll n;

    ll limit=0;

    vector <ll> input;

    cin >> n;

    REP(i,n){

        ll tmp;

        cin >> tmp;

        input.push_back(tmp);

        CHMAX(limit, tmp);

    }



    bool dp[1000010];

    REP(i, 1000010){

        dp[i] = true;

    }



    sort(ALL(input));



    REP(i,n){

        if(i>0){

            if(input[i]==input[i-1]){

                dp[input[i]] = false;

                continue;

            }

        }

        ll value = input[i]*2;

        while(value < limit +1){

//            if(dp[value] == false){

//                break;

//            }

            dp[value] = false;

            value +=  input[i];

        }

    }



        ll ans=0;

        REP(i,input.size()){

            if(dp[input[i]]){

                //cout << input[i] << endl;

                ans++;

            }

        }

        cout << ans << endl;

    return 0;

}

// Optimized solution to the same problem (faster):
// C

#ifndef _GLIBCXX_NO_ASSERT

#include <cassert>

#endif

#include <cctype>

#include <cerrno>

#include <cfloat>

#include <ciso646>

#include <climits>

#include <clocale>

#include <cmath>

#include <csetjmp>

#include <csignal>

#include <cstdarg>

#include <cstddef>

#include <cstdio>

#include <cstdlib>

#include <cstring>

#include <ctime>



#if __cplusplus >= 201103L

#include <ccomplex>

#include <cfenv>

#include <cinttypes>

// #include <cstdalign>

#include <cstdbool>

#include <cstdint>

#include <ctgmath>

#include <cwchar>

#include <cwctype>

#endif



// C++

#include <algorithm>

#include <bitset>

#include <complex>

#include <deque>

#include <exception>

#include <fstream>

#include <functional>

#include <iomanip>

#include <ios>

#include <iosfwd>

#include <iostream>

#include <istream>

#include <iterator>

#include <limits>

#include <list>

#include <locale>

#include <map>

#include <memory>

#include <new>

#include <numeric>

#include <ostream>

#include <queue>

#include <set>

#include <sstream>

#include <stack>

#include <stdexcept>

#include <streambuf>

#include <string>

#include <typeinfo>

#include <utility>

#include <valarray>

#include <vector>



#if __cplusplus >= 201103L

#include <array>

#include <atomic>

#include <chrono>

#include <condition_variable>

#include <forward_list>

#include <future>

#include <initializer_list>

#include <mutex>

#include <random>

#include <ratio>

#include <regex>

#include <scoped_allocator>

#include <system_error>

#include <thread>

#include <tuple>

#include <typeindex>

#include <type_traits>

#include <unordered_map>

#include <unordered_set>

#endif



using namespace std;

typedef long long int ll;

typedef unsigned long long ull;

typedef long double ld;

#define REP(i,n) for(ll i=0; i<(n); i++)

#define REPR(i, n) for(ll i = n;i >= 0;i--)

#define FOR(i, m, n) for(ll i = m;i < n;i++)

#define ALL(n) begin(n),end(n)

#define IN(a, x, b) (a<=x && x<b)

#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);

template<class T> inline T CHMAX(T & a, const T b) { return a = (a < b) ? b : a; }

template<class T> inline T CHMIN(T & a, const T b) { return a = (a > b) ? b : a; }



const long double EPS = 1e-10;

const long long INF = 1e18;

const long double PI = acos(-1.0L);

const long long MOD = 1000000007;





vector<long long> enum_divisors(long long N) {

    vector<long long> res;

    for (long long i = 1; i * i <= N; ++i) {

        if (N % i == 0) {

            res.push_back(i);

            // 重複しないならば i の相方である N/i も push

            if (N/i != i) res.push_back(N/i);

        }

    }

    // 小さい順に並び替える

    sort(res.begin(), res.end());

    return res;

}





int main(void){

    ll n;

    cin >>n;

    vector<ll> input(n);

    map<ll, ll> inputmap;

    REP(i,n){

        cin >> input[i];

        inputmap[input[i]]++;

    }



    ll cnt = n;

    REP(i,n){

        if(inputmap[input[i]] > 1){

            cnt--;

            continue;

        }

        const auto &res =enum_divisors(input[i]);



        for(auto x: res){

            if(x == input[i]){continue;}

            if(inputmap.find(x) != inputmap.end()){ 

                cnt--;

                break;

            }

        }

    }



    cout << cnt << endl;

    return 0;

}

// Fastest known solution for this problem: