source_code: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.InputStreamReader;
  import java.math.BigInteger;
  import java.security.KeyPair;
  import java.util.*;
  
  public class Main {
  
      static long[][] c ;
      static long[] arr;
      static long n , m , k;
      static long dp[][][];
  
      public static void main(String[] args) throws IOException {
          Reader.init(System.in);
          int n = Reader.nextInt();
          int[] arr = new int[n];
          int[] mark = new int[n];
          for (int i = 0 ; i < n  ; i++){
              arr[i] = Reader.nextInt();
          }
          Arrays.sort(arr);
          int[] v = new int[n];
          int ans = 0;
          for (int i = 0 ; i < n ; i++){
              if (v[i]==0){
                  for (int j = i ; j < n ; j++){
                      if (arr[j]%arr[i]==0){
                          v[j] = arr[i];
                      }
                  }
              }
          }
          TreeSet<Integer> s = new TreeSet<>();
          for (int i = 0 ; i < n ;i++){
              s.add(v[i]);
          }
          System.out.println(s.size());
  
  
  
  
  
          
      }
  
  
  
      public static void sortbyColumn_asc(int arr[][], int col)
      {
          // Using built-in sort function Arrays.sort
          Arrays.sort(arr, new Comparator<int[]>() {
  
              @Override
              // Compare values according to columns
              public int compare(final int[] entry1,
                                 final int[] entry2) {
  
                  // To sort in descending order revert
                  // the '>' Operator
                  if (entry1[col] > entry2[col])
                      return 1;
                  else
                      return -1;
              }
          });  // End of function call sort().
      }
  
      public static void sortbyColumn_dsc(int arr[][], int col)
      {
          // Using built-in sort function Arrays.sort
          Arrays.sort(arr, new Comparator<int[]>() {
  
              @Override
              // Compare values according to columns
              public int compare(final int[] entry1,
                                 final int[] entry2) {
  
                  // To sort in descending order revert
                  // the '>' Operator
                  if (entry1[col] > entry2[col])
                      return -1;
                  else
                      return 1;
              }
          });  // End of function call sort().
      }
  
      static void swap(char[] arr , int i , int j){
          char tmp = arr[i];
          arr[i] = arr[j];
          arr[j] = tmp;
      }
  
      static void swap(int[] arr , int i , int j){
          int tmp = arr[i];
          arr[i] = arr[j];
          arr[j] = tmp;
      }
  
  
  
  
  
  }
  
  class Node implements Comparable<Node>{
      int a ,  b;
      Node(int a , int b){
          this.a = a;
          this.b = b;
      }
      public int compareTo(Node o) {
          if (this.a == o.a){
              return this.b - o.b;
          }
          return this.a - o.a;
      }
  }
  class Edge implements Comparable<Edge>{
      int x , y , w;
  
      public Edge(int x, int y, int w) {
          this.x = x;
          this.y = y;
          this.w = w;
      }
  
      @Override
      public int compareTo(Edge o) {
          return this.w - o.w;
      }
  }
  class Reader {
      static BufferedReader reader;
      static StringTokenizer tokenizer;
  
      /** call this method to initialize reader for InputStream */
      static void init(InputStream input) {
          reader = new BufferedReader(
                  new InputStreamReader(input) );
          tokenizer = new StringTokenizer("");
      }
      /** get next word */
      static String next() throws IOException {
          while ( ! tokenizer.hasMoreTokens() ) {
              //TODO add check for eof if necessary
              tokenizer = new StringTokenizer(
                      reader.readLine() );
          }
          return tokenizer.nextToken();
      }
  
      static int nextInt() throws IOException {
          return Integer.parseInt( next() );
      }
      static long nextLong() throws IOException {
          return Long.parseLong( next() );
      }
  
      static double nextDouble() throws IOException {
          return Double.parseDouble( next() );
      }
  }
  class MergeSort
  {
      // Merges two subarrays of arr[].
      // First subarray is arr[l..m]
      // Second subarray is arr[m+1..r]
      void merge(int arr[], int l, int m, int r)
      {
          // Find sizes of two subarrays to be merged
          int n1 = m - l + 1;
          int n2 = r - m;
  
          /* Create temp arrays */
          int L[] = new int [n1];
          int R[] = new int [n2];
  
          /*Copy data to temp arrays*/
          for (int i=0; i<n1; ++i)
              L[i] = arr[l + i];
          for (int j=0; j<n2; ++j)
              R[j] = arr[m + 1+ j];
  
  
          /* Merge the temp arrays */
  
          // Initial indexes of first and second subarrays
          int i = 0, j = 0;
  
          // Initial index of merged subarry array
          int k = l;
          while (i < n1 && j < n2)
          {
              if (L[i] <= R[j])
              {
                  arr[k] = L[i];
                  i++;
              }
              else
              {
                  arr[k] = R[j];
                  j++;
              }
              k++;
          }
  
          /* Copy remaining elements of L[] if any */
          while (i < n1)
          {
              arr[k] = L[i];
              i++;
              k++;
          }
  
          /* Copy remaining elements of R[] if any */
          while (j < n2)
          {
              arr[k] = R[j];
              j++;
              k++;
          }
      }
  
      // Main function that sorts arr[l..r] using
      // merge()
      void sort(int arr[], int l, int r)
      {
          if (l < r)
          {
              // Find the middle point
              int m = (l+r)/2;
  
              // Sort first and second halves
              sort(arr, l, m);
              sort(arr , m+1, r);
  
              // Merge the sorted halves
              merge(arr, l, m, r);
          }
      }
  
      /* A utility function to print array of size n */
      static void printArray(int arr[])
      {
          int n = arr.length;
          for (int i=0; i<n; ++i)
              System.out.print(arr[i] + " ");
          System.out.println();
      }
  
      // Driver method
  
  }