source_code: 
  import java.io.*;
  import java.util.*;
  
  public class Main {
      private final static long mod = 1000000007;
  
      private final static int MAXN = 100001;
  
      private static long power(long x, long y, long m) {
          long temp;
          if (y == 0)
              return 1;
          temp = power(x, y / 2, m);
          temp = (temp * temp) % m;
          if (y % 2 == 0)
              return temp;
          else
              return ((x % m) * temp) % m;
      }
  
      private static long power(long x, long y) {
          return power(x, y, mod);
      }
  
      private static long gcd(long a, long b) {
          if (b == 0) return a;
          return gcd(b, a % b);
      }
  
      static int nextPowerOf2(int a) {
          return 1 << nextLog2(a);
      }
  
      static int nextLog2(int a) {
          return (a == 0 ? 0 : 32 - Integer.numberOfLeadingZeros(a - 1));
      }
  
      private static long modInverse(long a, long m) {
          long m0 = m;
          long y = 0, x = 1;
          if (m == 1)
              return 0;
          while (a > 1) {
              long q = a / m;
              long t = m;
              m = a % m;
              a = t;
              t = y;
              y = x - q * y;
              x = t;
          }
          if (x < 0)
              x += m0;
          return x;
      }
  
      private static int[] getLogArr(int n) {
          int arr[] = new int[n + 1];
          for (int i = 1; i < n + 1; i++) {
              arr[i] = (int) (Math.log(i) / Math.log(2) + 1e-10);
          }
          return arr;
      }
  
      private static int log[] = getLogArr(MAXN);
  
      private static int getLRMax(int st[][], int L, int R) {
          int j = log[R - L + 1];
          return Math.max(st[L][j], st[R - (1 << j) + 1][j]);
      }
  
      private static int[][] getSparseTable(int array[]) {
          int k = log[MAXN] + 1;
          int st[][] = new int[MAXN][k + 1];
  
          for (int i = 0; i < array.length; i++)
              st[i][0] = array[i];
  
          for (int j = 1; j <= k; j++) {
              for (int i = 0; i + (1 << j) <= array.length; i++) {
                  st[i][j] = Math.max(st[i][j - 1], st[i + (1 << (j - 1))][j - 1]);
              }
          }
          return st;
      }
  
      static class Subset {
          int parent;
          int rank;
  
          @Override
          public String toString() {
              return "" + parent;
          }
      }
  
      static int find(Subset[] Subsets, int i) {
          if (Subsets[i].parent != i)
              Subsets[i].parent = find(Subsets, Subsets[i].parent);
          return Subsets[i].parent;
      }
  
      static void union(Subset[] Subsets, int x, int y) {
          int xroot = find(Subsets, x);
          int yroot = find(Subsets, y);
  
          if (Subsets[xroot].rank < Subsets[yroot].rank)
              Subsets[xroot].parent = yroot;
          else if (Subsets[yroot].rank < Subsets[xroot].rank)
              Subsets[yroot].parent = xroot;
          else {
              Subsets[xroot].parent = yroot;
              Subsets[yroot].rank++;
          }
      }
  
  
      private static int maxx(Integer... a) {
          return Collections.max(Arrays.asList(a));
      }
  
  
      private static class Pair<T, U> {
          T a;
          U b;
  
          public Pair(T a, U b) {
              this.a = a;
              this.b = b;
          }
  
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
              Pair pair = (Pair) o;
              return a.equals(pair.a) &&
                      b.equals(pair.b);
          }
  
          @Override
          public int hashCode() {
              return Objects.hash(a, b);
          }
  
          @Override
          public String toString() {
              return "(" + a +
                      "," + b +
                      ')';
          }
      }
  
  
      public static void main(String[] args) throws Exception {
          try (FastReader in = new FastReader();
               FastWriter out = new FastWriter()) {
              int t, i, j, n, k, l, r, m, c, p, q, ti, tidx;
              long x, y, z;
  
              //for (t = in.nextInt(), tidx = 1; tidx <= t; tidx++)
              {
                  //out.print(String.format("Case #%d: ", tidx));
                  n=in.nextInt();
                  int a[]=new int[101];
                  for (i=0;i<n;i++){
                      a[in.nextInt()]++;
                  }
                  m=0;
                  for(i=1;i<101;i++){
                      if(a[i]>0){
                          m++;
                          for(j=i;j<=100;j+=i){
                              a[j]=0;
                          }
                      }
                  }
                  out.println(m);
              }
              out.commit();
          }
      }
  
  
      static class FastReader implements Closeable {
          private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
          private StringTokenizer st;
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (Exception e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
  
          int[] nextIntArr(int n) {
              int[] arr = new int[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextInt();
              }
              return arr;
          }
  
          double[] nextDoubleArr(int n) {
              double[] arr = new double[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextDouble();
              }
              return arr;
          }
  
          long[] nextLongArr(int n) {
              long[] arr = new long[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextLong();
              }
              return arr;
          }
  
          String[] nextStrArr(int n) {
              String[] arr = new String[n];
              for (int i = 0; i < n; i++) {
                  arr[i] = next();
              }
              return arr;
          }
  
          int[][] nextIntArr2(int n, int m) {
              int[][] arr = new int[n][m];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextIntArr(m);
              }
              return arr;
          }
  
          long[][] nextLongArr2(int n, int m) {
              long[][] arr = new long[n][m];
              for (int i = 0; i < n; i++) {
                  arr[i] = nextLongArr(m);
              }
              return arr;
          }
  
          @Override
          public void close() throws IOException {
              br.close();
          }
      }
  
  
      static class FastWriter implements Closeable {
          BufferedWriter bw;
          StringBuilder sb = new StringBuilder();
          List<String> list = new ArrayList<>();
          Set<String> set = new HashSet<>();
  
          FastWriter() {
              bw = new BufferedWriter(new OutputStreamWriter(System.out));
          }
  
          <T> void commit() throws IOException {
              bw.write(sb.toString());
              bw.flush();
              sb = new StringBuilder();
          }
  
          <T> void print(T obj) {
              sb.append(obj.toString());
          }
  
          void println() throws IOException {
              print("\n");
          }
  
          <T> void println(T obj) throws IOException {
              print(obj.toString() + "\n");
          }
  
          <T> void printArrLn(T[] arr) throws IOException {
              for (int i = 0; i < arr.length - 1; i++) {
                  print(arr[i] + " ");
              }
              println(arr[arr.length - 1]);
          }
  
          <T> void printArr2(T[][] arr) throws IOException {
              for (int j = 0; j < arr.length; j++) {
                  for (int i = 0; i < arr[j].length - 1; i++) {
                      print(arr[j][i] + " ");
                  }
                  println(arr[j][arr.length - 1]);
              }
          }
  
          <T> void printColl(Collection<T> coll) throws IOException {
              for (T e : coll) {
                  print(e + " ");
              }
              println();
          }
  
          void printCharN(char c, int n) throws IOException {
              for (int i = 0; i < n; i++) {
                  print(c);
              }
          }
  
          void printIntArr2(int[][] arr) throws IOException {
              for (int j = 0; j < arr.length; j++) {
                  for (int i = 0; i < arr[j].length - 1; i++) {
                      print(arr[j][i] + " ");
                  }
                  println(arr[j][arr.length - 1]);
              }
          }
  
          @Override
          public void close() throws IOException {
              bw.close();
          }
      }
  
  }
  