source_code: import java.io.BufferedWriter;
  import java.io.IOException;
  import java.io.InputStream;
  import java.io.OutputStream;
  import java.io.OutputStreamWriter;
  import java.io.PrintWriter;
  import java.io.Writer;
  import java.util.Arrays;
  import java.util.InputMismatchException;
  import java.util.*;
  import java.io.*;
  import java.math.*;
  public class Main6{
  
  static class Pair
  	{ 
  		int x;
  		int y;
  		int z;
  		public Pair(int x,int y,int z) 
  		{	 
  			this.x= x; 
  			this.y= y;
  			this.z=z;
  		}	 
  		
  	@Override
  			public int hashCode() 
  			{ 
  				final int temp = 14; 
  				int ans = 1; 
  				ans =x*31+y*13; 
  				return ans; 
  			} 
  	  
  			// Equal objects must produce the same 
  			// hash code as long as they are equal 
  		@Override
  		public boolean equals(Object o) 
  		{ 
  			if (this == o) { 
  				return true; 
  			} 
  			if (o == null) { 
  				return false; 
  			} 
  			if (this.getClass() != o.getClass()) { 
  				return false; 
  			} 
  			Pair other = (Pair)o; 
  			if (this.x != other.x || this.y!=other.y) { 
  				return false; 
  			} 
  			return true; 
  		} 
  			
  	} 
  	static class Pair1
  	{
  		String x;
  		int y;
  		int z;
  		
  	}
  	static class Compare
  	{ 
  		static void compare(Pair arr[], int n) 
  		{ 
  			// Comparator to sort the pair according to second element 
  		/*	Arrays.sort(arr, new Comparator<Pair>() { 
  				@Override public int compare(Pair p1, Pair p2) 
  				{ 
  					if(p1.start>p2.start)
  					{
  						return 1;
  					}
  					else if(p1.start==p2.start)
  					{
  						return 0;
  					}
  					else
  					{
  						return -1;
  					}
  				} 
  			}); */
  		}
  		
  	}
  	
  	
  	public static long pow(long a, long b)
  	{
  		long result=1;
  		while(b>0)
  		{
  			if (b % 2 != 0)
  			{
  				result=(result*a)%998244353;
  				b--;
  			} 
  			a=(a*a)%998244353;
  			b /= 2;
  		}   
  		return result;
  	}
  	public static long fact(long num)
  	{
  				long value=1;
  				int i=0;
  				for(i=2;i<num;i++)
  				{
  					value=((value%mod)*i%mod)%mod;
  				}
  				return value;
  			}
  			public static int gcd(int a, int b)
  			{
  				if (a == 0)
  					return b;
  				return gcd(b%a, a);
  			}
  			
  	/*		public static long lcm(long a,long b)
  			{
  				return a * (b / gcd(a, b));
  			}
  		*/	public static long sum(int h)
  			{
  				return (h*(h+1)/2);
  			}
  			public static void dfs(int parent,boolean[] visited,int[] dp)
  			{
  				ArrayList<Integer> arr=new ArrayList<Integer>();
  				arr=graph.get(parent);
  				visited[parent]=true;
  				for(int i=0;i<arr.size();i++)
  				{
  					int num=(int)arr.get(i);
  					if(visited[num]==false)
  					{
  						dfs(num,visited,dp);
  					}
  					dp[parent]=Math.max(dp[num]+1,dp[parent]);
  				}
  			}
  		//	static int flag1=0;
  			static int[] dis;
  			static int mod=1000000007;
  			static ArrayList<ArrayList<Integer>> graph;
  			
  			public static void bfs(int num,int size)
  			{
  				boolean[] visited=new boolean[size+1];
  				Queue<Integer> q=new LinkedList<>();
  				q.add(num);
  				ans[num]=1;
  				visited[num]=true;
  				while(!q.isEmpty())
  				{
  					int x=q.poll();
  					ArrayList<Integer> al=graph.get(x);
  					for(int i=0;i<al.size();i++)
  					{
  						int y=al.get(i);	
  						if(visited[y]==false)
  						{
  							q.add(y);
  							ans[y]=ans[x]+1;
  							visited[y]=true;
  						}
  					}
  				}
  			}
  			static int[] ans;
  			
  			
  			
  			
  			
  			
  			
  			
  			
  		//	static int[] a;			  
  			public static int[] sort(int[] a)
  			{
  				int n=a.length;
  				ArrayList<Integer> ar=new ArrayList<>();
  				for(int i=0;i<a.length;i++)
  				{
  					ar.add(a[i]);
  				}
  				Collections.sort(ar);
  				for(int i=0;i<n;i++)
  				{
  					a[i]=ar.get(i);
  				}
  				return a;
  			}
  			static public void main(String args[])throws IOException
  			{
  				int n=i();
  				int[] a=new int[n];
  				for(int i=0;i<n;i++)
  				{
  					a[i]=i();
  				}
  				Arrays.sort(a);
  				boolean[] flag=new boolean[n];
  				int ans=0;
  				for(int i=0;i<n;i++)
  				{
  					if(flag[i]==false)
  					{
  						ans++;
  						for(int j=0;j<n;j++)
  						{
  							if(a[j]%a[i]==0 && flag[j]==false)
  							{
  								flag[j]=true;
  							}
  						}
  					}
  				}
  				pln(ans+"");
  			}
  			
  			
  			
  			/**/
  			static InputReader in=new InputReader(System.in);
  				static OutputWriter out=new OutputWriter(System.out);
  				public static long l()
  				{
  					String s=in.String();
  					return Long.parseLong(s);
  				}
  				public static void pln(String value)
  				{
  					System.out.println(value);
  				}
  				public static int i()
  				{
  					return in.Int();
  				}
  				public static String s()
  				{
  					return in.String();
  				}
  	}
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		 
  		class InputReader {
  			 
  			private InputStream stream;
  			private byte[] buf = new byte[1024];
  			private int curChar;
  			private int numChars;
  			private SpaceCharFilter filter;
  		 
  			public InputReader(InputStream stream) {
  				this.stream = stream;
  			}
  		 
  			public int read() {
  				if (numChars== -1)
  					throw new InputMismatchException();
  				if (curChar >= numChars) {
  					curChar = 0;
  					try {
  						numChars = stream.read(buf);
  					} catch (IOException e) {
  						throw new InputMismatchException();
  					}
  					if (numChars <= 0)
  						return -1;
  				}
  				return buf[curChar++];
  			}
  		 
  			public int Int() {
  				int c = read();
  				while (isSpaceChar(c))
  					c = read();
  				int sgn = 1;
  				if (c == '-') {
  					sgn = -1;
  					c = read();
  				}
  				int res = 0;
  				do {
  					if (c < '0' || c > '9')
  						throw new InputMismatchException();
  					res *= 10;
  					res += c - '0';
  					c = read();
  				} while (!isSpaceChar(c));
  				return res * sgn;
  			}
  		 
  			public String String() {
  				int c = read();
  				while (isSpaceChar(c))
  					c = read();
  				StringBuilder res = new StringBuilder();
  				do {
  					res.appendCodePoint(c);
  					c = read();
  				} while (!isSpaceChar(c));
  				return res.toString();
  			}
  		 
  			public boolean isSpaceChar(int c) {
  				if (filter != null)
  					return filter.isSpaceChar(c);
  				return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
  			}
  		 
  			public String next() {
  				return String();
  			}
  		 
  			public interface SpaceCharFilter {
  				public boolean isSpaceChar(int ch);
  			}
  		}
  		 
  		class OutputWriter {
  			private final PrintWriter writer;
  		 
  			public OutputWriter(OutputStream outputStream) {
  				writer = new PrintWriter(new BufferedWriter(new OutputStreamWriter(outputStream)));
  			}
  		 
  			public OutputWriter(Writer writer) {
  				this.writer = new PrintWriter(writer);
  			}
  		 
  			public void print(Object...objects) {
  				for (int i = 0; i < objects.length; i++) {
  					if (i != 0)
  						writer.print(' ');
  					writer.print(objects[i]);
  				}
  			}
  		 
  			public void printLine(Object...objects) {
  				print(objects);
  				writer.println();
  			}
  		 
  			public void close() {
  				writer.close();
  			}
  		 
  			public void flush() {
  				writer.flush();
  			}
  		 
  			}
  		 
  			class IOUtils {
  		 
  			public static int[] readIntArray(InputReader in, int size) {
  				int[] array = new int[size];
  				for (int i = 0; i < size; i++)
  					array[i] = in.Int();
  				return array;
  			}
  		 
  			} 