using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {

        static void Main(string[] args)
        {
            Console.ReadLine();
            string[] input = Console.ReadLine().Split(' ');
            List<int> c = new List<int>();
            foreach (string i in input)
                c.Add(Int32.Parse(i));
            c = c.Distinct().ToList();
            c.Sort();
            List<int> cc = c.ToArray().ToList();
            cc.Reverse();
            int res = 0;
            List<int> bad = new List<int>();
            List<int> combo = new List<int>();
            foreach (int g in c)
            {
                if (bad.Contains(g))
                    continue;
                foreach (int h in cc)
                {
                    if (h % g == 0)
                    {
                        combo.Add(h);
                    }
                }
                //Console.WriteLine("COMBO! {0}", string.Join(" ", combo));
                if (combo.Count() > 0)
                    res += 1;
                foreach (int i in combo)
                {
                    bad.Add(i);
                }
            }

            Console.WriteLine(res);
            Console.ReadLine();
        }
    }
}

using System;
using System.Linq;

namespace codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int[] ch = Console.ReadLine().Split().Select(x => int.Parse(x)).ToArray();
            Array.Sort(ch);
            int rez = 0;
            for (int i = 0; i < n; i++)
            {
                if (ch[i] != 0)
                {
                    rez++;
                    for (int k = i + 1; k < n; k++)
                    {
                        if (ch[k] != 0 && ch[k] % ch[i] == 0)
                            ch[k] = 0;
                    }
                    ch[i]=0;
                }
            }
            rez += ch.GroupBy(x => x).Count() - 1;
            Console.WriteLine(rez);
        }
    }
}

using System;
using System.Linq;
using System.Collections.Generic;
namespace A._Paint_the_Numbers
{
    class Program
    {
        public class cmp : IComparer<int> {
            public int Compare (int a, int b) {
                if (a > b) return 1;
                else if (a == b) return 0;
                else return -1;
            }
        }
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int res = 0;
            int[] A = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
            cmp CMP = new cmp();
            Array.Sort(A, CMP);
            while (A.Count() > 0) {
                A = A.Where(k => (k % A[0]) != 0).ToArray();
                res++;
            }
            Console.WriteLine(res);
        }
    }
}

using System;

public class HelloA {
	public static void Main(){
		int n;
		int[] colors;
		int cnt = 0;
		Int32.TryParse(Console.ReadLine(), out n);
		colors = new int[n];
		string [] data = Console.ReadLine().Split(' ');
		for(int i = 0; i < n; i++)
			Int32.TryParse(data[i], out colors[i]);
		for(int i = 0; i < colors.Length-1; i++){
			for(int j = i + 1; j < colors.Length; j++){
				if(colors[j] < colors[i]) {
					int t = colors[j];
					colors[j] = colors[i];
					colors[i] = t;
				}
			}
		}
		for(int i = 0; i < colors.Length; i++){
			if(colors[i] == -1) continue;
			cnt++;
			int the_color = colors[i];
			for(int j = i; j < colors.Length; j++){
				if((colors[j] % the_color) == 0) colors[j] = -1;
			}
		}
		Console.WriteLine(cnt);
	}
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Numerics;

namespace cf584
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.SetIn(new StreamReader("input.txt"));
            solve_cf584A();
        }

        public static void solve_cf584A()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[] a = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
            int[] cnt = new int[101];

            Array.Sort(a);
            int min = 0;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (a[j] % a[i] == 0)
                    {
                        if (cnt[a[i]] == 0)
                        {
                            min++;
                            cnt[a[i]]++;
                        }
                            cnt[a[j]]++;
                    }
                }
            }

            /*for (int i = 0; i < n; i++)
            {
                if (cnt[a[i]] == 0)
                {
                    min++;
                }
            }*/

            Console.WriteLine(min);
        }
    }
}

using System;
using System.ComponentModel;

public class Program
{

    public void Solve()
    {
        var sc = new Scanner();
        int N = sc.NextInt();
        int[] A = sc.IntArray();

        Array.Sort(A);

        int ans = 0;

        for (int i = 0; i < N; i++)
        {
            if (A[i] > 0)
            {
                ans++;
                int t = A[i];
                for (int j = 0; j < N; j++)
                {
                    if (A[j] % t == 0)
                    {
                        A[j] = 0;
                    }
                }
            }

        }

        Console.WriteLine(ans);
    }

    public static void Main(string[] args)
    {
        new Program().Solve();
    }
}

class Scanner
{
    public Scanner()
    {
        _pos = 0;
        _line = new string[0];
    }

    const char Separator = ' ';
    private int _pos;
    private string[] _line;

    #region スペース区切りで取得

    public string Next()
    {
        if (_pos >= _line.Length)
        {
            _line = Console.ReadLine().Split(Separator);
            _pos = 0;
        }

        return _line[_pos++];
    }

    public int NextInt()
    {
        return int.Parse(Next());
    }

    public long NextLong()
    {
        return long.Parse(Next());
    }

    public double NextDouble()
    {
        return double.Parse(Next());
    }

    #endregion

    #region 型変換

    private int[] ToIntArray(string[] array)
    {
        var result = new int[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = int.Parse(array[i]);
        }

        return result;
    }

    private long[] ToLongArray(string[] array)
    {
        var result = new long[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = long.Parse(array[i]);
        }

        return result;
    }

    private double[] ToDoubleArray(string[] array)
    {
        var result = new double[array.Length];
        for (int i = 0; i < array.Length; i++)
        {
            result[i] = double.Parse(array[i]);
        }

        return result;
    }

    #endregion

    #region 配列取得

    public string[] Array()
    {
        if (_pos >= _line.Length)
            _line = Console.ReadLine().Split(Separator);

        _pos = _line.Length;
        return _line;
    }

    public int[] IntArray()
    {
        return ToIntArray(Array());
    }

    public long[] LongArray()
    {
        return ToLongArray(Array());
    }

    public double[] DoubleArray()
    {
        return ToDoubleArray(Array());
    }

    #endregion
}

using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
class Solution
{
    static void Main(string[] args)
    {
        ReadLine();
        List<int> b = new List<int>(Array.ConvertAll(ReadLine().Split(), int.Parse));
        b.Sort();
        for (int i = 0; i < b.Count-1; i++)
        {
            for (int j = i+1; j < b.Count; j++)
            {
                if (b[j] % b[i] == 0)
                {
                    b.Remove(b[j]);
                    j = i;
                }
            }
        }
        WriteLine(b.Count);

    }
}

using System;
using System.Collections.Generic;
class Program
{
	static void Main(string[] args)
	{
		int N = int.Parse(Console.ReadLine());
		string[] str = Console.ReadLine().Split();
		int[]A = new int[N];
		for(var i=0;i<N;i++){
			A[i] = int.Parse(str[i]);
		}
		Array.Sort(A);
		var list = new List<int>();
		for(var i=0;i<N;i++){
			bool flag = false;
			for(var j=0;j<list.Count;j++){
				if(A[i]%list[j]==0){
					flag = true;
					break;
				}
			}
			if(!flag){
				list.Add(A[i]);
			}
		}
		Console.WriteLine(list.Count);
	}
}

using System;
using System.Linq;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            int n = int.Parse(Console.ReadLine());
            int counter = 0;
            var numbers = Console.ReadLine().Split(' ').Select(f => int.Parse(f)).ToArray();
            Array.Sort(numbers);
            for (int i = 0; i < numbers.Length; i++)
            {
                if (numbers[i]!=0)
                {
                    for (int j = i + 1; j < numbers.Length; j++)
                    {
                        if (numbers[j] % numbers[i] == 0 && numbers[j]!=0)
                        {
                            numbers[j] = 0;
                        }
                    }
                    numbers[i] = 0;
                    counter++;
                }

            }

            Console.WriteLine(counter.ToString());
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using static System.Console;
using static System.Convert;
using static System.Math;
//using static System.Globalization.CultureInfo;
using System.Text;
class Program
{
    public static bool chmin<T>(ref T num, T val) where T : IComparable<T>
    { if (num.CompareTo(val) == 1) { num =val; return true; } return false; }
    public static bool chmax<T>(ref T num, T val) where T : IComparable<T>
    { if (num.CompareTo(val) == -1) { num = val; return true; } return false; }
    public static void swap<T>(ref T v1, ref T v2)
    { var t = v2; v2 = v1; v1 = t; }
    static void Main(string[] args)
    {
        var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
        Console.SetOut(sw);
        new Program().Solve();
        Console.Out.Flush();
    }
    void Solve()
    {
        var num = Input.num;
        var ar = Input.ar;Array.Sort(ar);
        var th = new bool[num];
        var ct = 0;
        for(var i=0;i<num;i++)
        {
            if (th[i]) continue;
            ct++;
            for (var j = i + 1; j < num; j++)
                th[j] |= ar[j] % ar[i] == 0;
        }
        WriteLine(ct);
    }
}

public class Input
{
    public static string read => ReadLine().Trim();
    public static int[] ar => read.Split(' ').Select(int.Parse).ToArray();
    public static int num => ToInt32(read);
    public static long[] arL => read.Split(' ').Select(long.Parse).ToArray();
    public static long numL => ToInt64(read);
    public static T[] create<T>(int n, Func<int, T> f)
        => Enumerable.Repeat(0, n).Select(f).ToArray();
    public static char[][] grid(int h)
        => create(h, _ => read.ToCharArray());
    public static int[] ar1D(int n)
        => create(n, _ => num);
    public static long[] arL1D(int n)
        => create(n, _ => numL);
    public static string[] strs(int n)
        => create(n, _ => read);
    public static int[][] ar2D(int n)
        => create(n, _ => ar);
    public static long[][] arL2D(int n)
        => create(n, _ => arL);
    public static List<T>[] edge<T>(int n)
        => create(n, _ => new List<T>());
    public static T GetValue<T>(string g)
    {
        var t = typeof(T);
        if (t == typeof(int))
            return (T)(object)int.Parse(g);
        if (t == typeof(long))
            return (T)(object)long.Parse(g);
        if (t == typeof(string))
            return (T)(object)g;
        if (t == typeof(char))
            return (T)(object)char.Parse(g);
        if (t == typeof(double))
            return (T)(object)double.Parse(g);
        if (t == typeof(bool))
            return (T)(object)bool.Parse(g);
        return default(T);
    }
    public static void Make<T1, T2>(out T1 v1, out T2 v2)
    {
        v1 = Next<T1>();
        v2 = Next<T2>();
    }
    public static void Make<T1, T2, T3>(out T1 v1, out T2 v2, out T3 v3)
    {
        Make(out v1, out v2);
        v3 = Next<T3>();
    }
    public static void Make<T1, T2, T3, T4>(out T1 v1, out T2 v2, out T3 v3, out T4 v4)
    {
        Make(out v1, out v2, out v3);
        v4 = Next<T4>();
    }
    public static void Make<T1, T2, T3, T4, T5>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5)
    {
        Make(out v1, out v2, out v3, out v4);
        v5 = Next<T5>();
    }
    public static void Make<T1, T2, T3, T4, T5, T6>(out T1 v1, out T2 v2, out T3 v3, out T4 v4, out T5 v5, out T6 v6)
    {
        Make(out v1, out v2, out v3, out v4, out v5);
        v6 = Next<T6>();
    }
    private static Queue<string> sc;
    public static T Next<T>() { sc = sc ?? new Queue<string>(); if (sc.Count == 0) foreach (var item in read.Split(' ')) sc.Enqueue(item); return GetValue<T>(sc.Dequeue()); }
    public static void Next<T>(ref T val) => val = Next<T>();
    public const long Inf = (long)1e18;
    public const double eps = 1e-6;
    public const string Alfa = "abcdefghijklmnopqrstuvwxyz";
    public const int MOD = 1000000007;
}

public class Pair<T1, T2> : IComparable<Pair<T1, T2>>
{
    public T1 v1 { get; set; }
    public T2 v2 { get; set; }
    public Pair() { v1 = Input.Next<T1>(); v2 = Input.Next<T2>(); }
    public Pair(T1 v1, T2 v2)
    { this.v1 = v1; this.v2 = v2; }

    public int CompareTo(Pair<T1, T2> p)
    {
        var c = Comparer<T1>.Default.Compare(v1, p.v1);
        if (c == 0)
            c = Comparer<T2>.Default.Compare(v2, p.v2);
        return c;
    }
    public override string ToString()
        => $"{v1.ToString()} {v2.ToString()}";
    public override bool Equals(object obj)
        => this == (Pair<T1, T2>)obj;
    public override int GetHashCode()
        => v1.GetHashCode() ^ v2.GetHashCode();
    public static bool operator ==(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) == 0;
    public static bool operator !=(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) != 0;
    public static bool operator >(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) == 1;
    public static bool operator >=(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) != -1;
    public static bool operator <(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) == -1;
    public static bool operator <=(Pair<T1, T2> p1, Pair<T1, T2> p2)
        => p1.CompareTo(p2) != 1;
}

public class Pair<T1, T2, T3> : Pair<T1, T2>, IComparable<Pair<T1, T2, T3>>
{
    public T3 v3 { get; set; }
    public Pair() : base() { v3 = Input.Next<T3>(); }
    public Pair(T1 v1, T2 v2, T3 v3) : base(v1, v2)
    { this.v3 = v3; }

    public int CompareTo(Pair<T1, T2, T3> p)
    {
        var c = base.CompareTo(p);
        if (c == 0)
            c = Comparer<T3>.Default.Compare(v3, p.v3);
        return c;
    }
    public override string ToString()
        => $"{base.ToString()} {v3.ToString()}";
}

using System;
using System.IO;
using System.Text;

namespace Paint_the_Numbers
{
    internal class Program
    {
        private static readonly StreamReader reader = new StreamReader(Console.OpenStandardInput(1024*10), Encoding.ASCII, false, 1024*10);
        private static readonly StreamWriter writer = new StreamWriter(Console.OpenStandardOutput(1024*10), Encoding.ASCII, 1024*10);

        private static void Main(string[] args)
        {
            writer.WriteLine(Solve(args));
            writer.Flush();
        }

        private static int Solve(string[] args)
        {
            int n = Next();

            var nn = new int[n];
            for (int i = 0; i < n; i++)
            {
                nn[i] = Next();
            }

            Array.Sort(nn);
            int ans = 0;

            for (int i = 0; i < n; i++)
            {
                if (nn[i] == 0)
                    continue;
                ans++;
                for (int j = i + 1; j < n; j++)
                {
                    if (nn[j] != 0 && nn[j]%nn[i] == 0)
                        nn[j] = 0;
                }
            }

            return ans;
        }

        private static int Next()
        {
            int c;
            int res = 0;
            do
            {
                c = reader.Read();
                if (c == -1)
                    return res;
            } while (c < '0' || c > '9');
            res = c - '0';
            while (true)
            {
                c = reader.Read();
                if (c < '0' || c > '9')
                    return res;
                res *= 10;
                res += c - '0';
            }
        }
    }
}

using System;

public class a{
    public static void Main() {
        int n = Convert.ToInt32(Console.ReadLine());
        var b = Array.ConvertAll(Console.ReadLine().Trim().Split(), int.Parse);
        int i = 0, cnt = 0;
        Array.Sort(b);
        int[] ar = new int[101];
        for(i=0; i<n; i++) {

            if(ar[ b[i] ]==0) {
                for(int j = i; j<n; j++) {
                    if(b[j]%b[i]==0) {
                        ar[ b[j] ]++;
                    }
                }
                cnt++;
            }

        }
        Console.WriteLine(cnt);
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace codeforces
{
    class Program
    {
        static void Main(string[] args)
        {
            int input = Int32.Parse(Console.ReadLine());
            int res = 0;
            var nums = Console.ReadLine().Split(' ').Select(Int32.Parse).ToList();
            nums.Sort();
            while (nums.Count != 0)
            {
                int el = nums[0];
                for (int i = 0; i < nums.Count; i++)
                {
                    if (nums[i] % el == 0)
                    {
                        nums.RemoveAt(i);

                        i--;
                    }
                }
                res++;
            }
            Console.WriteLine(res);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Text;
using System.IO;
using System.Linq;

namespace ConsoleApp1
{
    class Program
    {

        static void Main(string[] args)
        {
            var n = int.Parse(Console.ReadLine());
            var numbers = Console.ReadLine().Split(' ').Select(int.Parse).ToList();

            numbers.Sort((a, b) => a.CompareTo(b));

            var colors = 0;
            while(numbers.Count > 0) {
                colors++;
                var currentNumber = numbers.First();
                for(var i=0; i< numbers.Count; i++)
                {
                    if(numbers[i] % currentNumber == 0)
                    {
                        numbers.RemoveAt(i);
                        i--;
                    }
                }
            }

            Console.WriteLine(colors);
        }

    }
}

/*
csc -debug A.cs && mono --debug A.exe <<< "6
10 2 3 5 4 2"
*/

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Reflection;

public class HelloWorld {
    public static void SolveCodeForces() {
        var n = cin.NI();
        var A = cin.NIA();

        var ans = 0;

        while (A.Length > 0) {
            ans++;
            var min = A.Min();
            A = A.Where(a => a % min != 0).ToArray();
        }

        System.Console.WriteLine(ans);
    }

    static Scanner cin = new Scanner();
    static StringBuilder cout = new StringBuilder();

    static public void Main () {
        SolveCodeForces();
        // IncreaseStack(SolveCodeForces);
        // System.Console.Write(cout.ToString());
    }

    public static void IncreaseStack(ThreadStart action, int stackSize = 128000000)
    {
        var thread = new Thread(action, stackSize);
        thread.Start();
        thread.Join();
    }
}

public static class Helpers {
    public static string Join<T>(this IEnumerable<T> arr, string sep = " ") {
        return string.Join(sep, arr);
    }

    public static void Swap<T>(ref T a, ref T b) {
        var tmp = a;
        a = b;
        b = tmp;
    }

    public static T[] CreateArray<T>(int length, Func<int, T> itemCreate) {
        var result = new T[length];
        for (var i = 0; i < result.Length; i++)
            result[i] = itemCreate(i);
        return result;
    }
}

public class Scanner
{
    private string[] line = new string[0];
    private int index = 0;

    public string Next() {
        if (line.Length <= index) {
            line = Console.ReadLine().Split(' ');
            index = 0;
        }
        var res = line[index];
        index++;
        return res;
    }

    public int NI() {
        return int.Parse(Next());
    }

    public long NL() {
        return long.Parse(Next());
    }

    public ulong NUL() {
        return ulong.Parse(Next());
    }

    public string[] Array() {
        line = Console.ReadLine().Split(' ');
        index = line.Length;
        return line;
    }

    public int[] NIA(int emptyPrefixLen = 0) {
        var array = Array();
        var result = new int[emptyPrefixLen + array.Length];
        for (int i = 0; i < array.Length; i++)
            result[emptyPrefixLen + i] = int.Parse(array[i]);
        return result;
    }

    public long[] NLA() {
        var array = Array();
        var result = new long[array.Length];
        for (int i = 0; i < array.Length; i++)
            result[i] = long.Parse(array[i]);
        return result;
    }

    public ulong[] NULA() {
        var array = Array();
        var result = new ulong[array.Length];
        for (int i = 0; i < array.Length; i++)
            result[i] = ulong.Parse(array[i]);
        return result;
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.IO;
using System.Text;
using static System.Math;
using static System.Array;
using static AtCoderSolve.Tool;

namespace AtCoderSolve
{
    class Solve
    {
        const int mod = 1000000007;
        const int INF = int.MaxValue / 2;
        const long SINF = long.MaxValue / 2;

        static void Main(string[] args)
        {
            //var sw = new StreamWriter(Console.OpenStandardOutput()) { AutoFlush = false };
            //Console.SetOut(sw);
            var cin = new Scanner();

            int n = int.Parse(Console.ReadLine());
            var a = cin.SplitReader();
            Sort(a);
            bool[] div = new bool[n];
            Initialize(ref div, false);
            long ans = 0;

            for(var i = 0; i < n; i++)
            {
                if (div[i]) { continue; }
                ans++;
                for(var j = 0; j < n; j++)
                {
                    if (i == j) { continue; }
                    if (a[j] % a[i] == 0)
                    {
                        div[j] = true;
                    }
                }
            }

            Console.WriteLine(ans);

            //Console.Out.Flush();
        }

    }

    public class Scanner
    {
        public int[] SplitReader()
        {
            int[] array = Console.ReadLine().Split().Select(int.Parse).ToArray();
            return array;
        }
        public long[] SplitReaderL()
        {
            long[] array = Console.ReadLine().Split().Select(long.Parse).ToArray();
            return array;
        }
    }

    public static class Tool
    {
        static public void Initialize<T>(ref T[] array, T initialvalue)
        {
            for(var i = 0; i < array.Length; i++)
            {
                array[i] = initialvalue;
            }
        }
        static public long ModuloP(long value,long mod)
        {
            long r = value % mod;

            if (r * mod < 0)
            {
                r += mod;
            }
            return r;
        }

    }

    struct Pair<T> : IComparable<Pair<T>> where T : IComparable<T>
    {
        public T variable;
        public int index;

        public Pair(T val, int i)
        {
            variable = val;
            index = i;
        }

        public int CompareTo(Pair<T> otherPair)
        {
            return variable.CompareTo(otherPair.variable);
        }

        public int CompareIndex(Pair<T> otherPair)
        {
            return index.CompareTo(otherPair.index);
        }
    }

}

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;

namespace Contest
{
    class Program
    {
        static void Main()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            var a = Array.ConvertAll(Console.ReadLine().Split(), Convert.ToInt32).OrderBy(x=>x).ToList();
            for(int i=0;i<a.Count();i++)
            {
                for (int j = i + 1; j < a.Count(); j++)
                    if (a[j] % a[i] == 0) a.RemoveAt(j--);
            }
            Console.WriteLine(a.Count());
        }

    }

}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

class Solution
{
	public static void Main (string[] args)
	{
		Console.ReadLine ();
		List<int> nums = Console.ReadLine ().Split (' ').Select (int.Parse).Distinct ().ToList ();
		int result = 0;
		while (nums.Count > 0) {
			int min = nums.Min ();
			nums = nums.Where (n => n % min != 0).ToList ();
			result++;
		}

		Console.WriteLine (result);
	}
}

// Problem: 1209A - Paint the Numbers
// Author: Gusztav Szmolik

using System;

class PaintTheNumbers
	{
	static int Main ()
		{
		string line = Console.ReadLine ();
		if (line == null)
			return -1;
		char[] delims = {' ', '\t'};
		string[] words = line.Split (delims,StringSplitOptions.RemoveEmptyEntries);
		if (words.Length != 1)
			return -1;
		byte n;
		if (!Byte.TryParse (words[0], out n))
			return -1;
		if (n < 1 || n > 100)
			return -1;
		line = Console.ReadLine ();
		if (line == null)
			return -1;
		words = line.Split (delims,StringSplitOptions.RemoveEmptyEntries);
		if (words.Length != n)
			return -1;
		bool[] existNumbers = new bool[100];
		Array.Clear (existNumbers,0,100);
		for (byte i = 0; i < n; i++)
			{
			byte ai;
			if (!Byte.TryParse (words[i], out ai))
				return -1;
			if (ai < 1 || ai > 100)
				return -1;
			if (!existNumbers[ai-1])
				existNumbers[ai-1] = true;
			}
		byte ans = 0;
		for (byte i = 0; i < 100; i++)
			if (existNumbers[i])
				{
				byte j = i;
				while (j < 100)
					{
					existNumbers[j] = false;
					j += Convert.ToByte (i+1);
					}
				ans++;
				}
		Console.WriteLine (ans);
		return 0;
		}
	}

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading.Tasks;
using static Codeforces.IO;
using static System.Linq.Enumerable;

namespace Codeforces
{
    static class IO
    {
        static StringBuilder builder = new StringBuilder();
        static Dummy dummy = new Dummy();
        class Dummy
        {
            ~Dummy()
            {
                Console.Write(builder);
            }
        }
        public static void Write(object obj)
        {
            builder.Append(obj);
        }
        public static void WriteLine(object obj)
        {
            builder.AppendLine(obj.ToString());
        }
        public static void Write(params object[] objs)
        {
            if (objs.Length != 0)
            {
                Write(objs[0]);
                for (var i = 1; i < objs.Length; ++i)
                {
                    Write(" ");
                    Write(objs[i]);
                }
            }
        }
        public static void WriteLine(params object[] objs)
        {
            Write(objs);
            WriteLine();
        }

        public static void WriteLine()
        {
            builder.AppendLine();
        }

        public static string ReadLine()
        {
            return Console.ReadLine();
        }
        public static T[] ReadArray<T>(Func<string, T> parser)
        {
            return ReadLine().Split(' ').Select(parser).ToArray();
        }
        public static (T, T) ReadTuple2<T>(Func<string, T> parser)
        {
            var ar = ReadArray(parser);
            return (ar[0], ar[1]);
        }
        public static (T, T, T) ReadTuple3<T>(Func<string, T> parser)
        {
            var ar = ReadArray(parser);
            return (ar[0], ar[1], ar[2]);
        }
    }

    static class Program
    {
        static void Main(string[] args)
        {
            var N = int.Parse(ReadLine());
            var set = new SortedSet<int>(ReadArray(int.Parse));
            var result = 0;
            for (; set.Count != 0; ++result)
            {
                var c = set.Min;
                for(var i = c; i <= 100; i += c)
                {
                    set.Remove(i);
                }
            }
            WriteLine(result);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Problem
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.ReadLine();
            List<long> nums = Console.ReadLine().Split(' ').Select(long.Parse).Distinct().ToList();
            int result = 0;
            while (nums.Count > 0)
            {
                long min = nums.Min();
                nums = nums.Where(n => n % min != 0).ToList();
                result++;
            }

            Console.WriteLine(result);
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Numerics;

namespace cf584
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.SetIn(new StreamReader("input.txt"));
            solve_cf584A();
        }

        public static void solve_cf584A()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[] a = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
            int[] cnt = new int[101];

            int min = 0;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i != j && a[j] % a[i] == 0)
                    {
                        if (cnt[a[i]] == 0)
                        {
                            min++;
                        }
                        cnt[a[j]]++;
                        cnt[a[i]]++;
                    }
                }
            }

            for (int i = 0; i < n; i++)
            {
                if (cnt[a[i]] == 0)
                {
                    min++;
                }
            }

            Console.WriteLine(min);
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Numerics;

namespace cf584
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.SetIn(new StreamReader("input.txt"));
            solve_cf584A();
        }

        public static void solve_cf584A()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[] a = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
            int[] cnt = new int[101];

            int min = 0;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i != j && a[j] % a[i] == 0)
                    {
                        if (cnt[a[j]] == 0)
                        {
                            min++;
                        }
                        cnt[a[j]]++;
                        cnt[a[i]]++;
                    }
                }
            }

            for (int i = 0; i < n; i++)
            {
                if (cnt[a[i]] == 0)
                {
                    min++;
                }
            }

            Console.WriteLine(min);
        }
    }
}

using System;
using System.IO;
using System.Collections.Generic;
using System.Numerics;

namespace cf584
{
    class Program
    {
        static void Main(string[] args)
        {
            //Console.SetIn(new StreamReader("input.txt"));
            solve_cf584A();
        }

        public static void solve_cf584A()
        {
            int n = Convert.ToInt32(Console.ReadLine());
            int[] a = Array.ConvertAll(Console.ReadLine().Split(' '), int.Parse);
            int[] cnt = new int[101];

            int min = 0;
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < n; j++)
                {
                    if (i != j && a[j] % a[i] == 0)
                    {
                        if (cnt[a[j]] == 0)
                        {
                            min++;
                        }
                        cnt[a[j]]++;
                    }
                }
            }

            Console.WriteLine(min);
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using static System.Console;
class Solution
{
    static void Main(string[] args)
    {
        ReadLine();
        int []b = Array.ConvertAll(ReadLine().Split(), int.Parse);
        Array.Sort(b);
        HashSet<int>a=new HashSet<int>();
        for (int i = 0; i < b.Length; i++)
        {
            for (int j = 2; j <= b[i]; j++)
            {
                if (b[i] % j == 0)
                {
                    a.Add(j);
                    break;
                }
            }
        }
        WriteLine(a.Count>0?a.Count:1);

    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static List<int> Mnosh(int n)
        {
            List<int> nn = new List<int>();
            for(int i = 1; i <= n; i++)
            {
                if (n % i == 0)
                    nn.Add(i);
            }
            return nn;
        }
        static void Main(string[] args)
        {
            Console.ReadLine();
            string[] input = Console.ReadLine().Split(' ');
            List<int> c = new List<int>();
            foreach (string i in input)
                c.Add(Int32.Parse(i));
            c = c.Distinct().ToList();
            c.Sort();
            c.Reverse();
            int res = 0;
            int ii = 0;
            while(c.Count() != 0)
            {
                List<int> m = Mnosh(c[0]);
                List<int> combo = new List<int>();
                foreach (int h in m)
                {
                    if (c.Contains(h))
                        combo.Add(h);
                }
                //Console.WriteLine("COMBO! {0}", string.Join(" ", combo));
                if (combo.Count() > 0)
                    res += 1;
                foreach (int i in combo)
                {
                    c.Remove(i);
                }
                //ii++;
            }
            Console.WriteLine(res);
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {

        static void Main(string[] args)
        {
            Console.ReadLine();
            string[] input = Console.ReadLine().Split(' ');
            List<int> c = new List<int>();
            foreach (string i in input)
                c.Add(Int32.Parse(i));
            c = c.Distinct().ToList();
            c.Sort();
            List<int> cc = c.ToArray().ToList();
            cc.Reverse();
            int res = 0;
            List<int> bad = new List<int>();
            List<int> combo = new List<int>();
            foreach (int g in c)
            {
                if (bad.Contains(g))
                    continue;
                foreach (int h in cc)
                {
                    if (h % g == 0)
                    {
                        combo.Add(h);
                    }
                }
                Console.WriteLine("COMBO! {0}", string.Join(" ", combo));
                if (combo.Count() > 0)
                    res += 1;
                foreach (int i in combo)
                {
                    bad.Add(i);
                }
            }

            Console.WriteLine(res);
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp6
{
    class Program
    {
        static List<int> Mnosh(int n)
        {
            List<int> nn = new List<int>();
            for(int i = 1; i <= n; i++)
            {
                if (n % i == 0)
                    nn.Add(i);
            }
            nn.Reverse();
            if(nn.Count() == 1)
            {
                nn.Add(1);
            }
            return nn;
        }

        static void Main(string[] args)
        {
            Console.ReadLine();
            string[] input = Console.ReadLine().Split(' ');
            List<int> c = new List<int>();
            foreach (string i in input)
                c.Add(Int32.Parse(i));
            c = c.Distinct().ToList();
            c.Sort();
            c.Reverse();
            int res = 0;
            while(c.Count() != 0)
            {
                List<int> m = Mnosh(c[0]);
                List<int> combo = new List<int>();
                foreach (int h in m)
                {
                    if (c.Contains(h) && h % m[1] == 0)
                        combo.Add(h);
                }
                //Console.WriteLine("COMBO! {0}", string.Join(" ", combo));
                if (combo.Count() > 0)
                    res += 1;
                foreach (int i in combo)
                {
                    c.Remove(i);
                }
            }
            Console.WriteLine(res);
            Console.ReadLine();
        }
    }
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

class Solution
{
	public static void Main (string[] args)
	{
		Console.ReadLine ();
		List<int> nums = Console.ReadLine ().Split (' ').Select (int.Parse).ToList ();
		int result = 0;
		for (int i = 2; nums.Count > 0 && i <= nums.Max (); i++) {
			List<int> div = nums.Where (x => x % i == 0).ToList ();
			if (div.Count > 0) {
				nums = nums.Where (x => x % i != 0).ToList ();
				result++;
			}
		}
		Console.WriteLine (result);
	}
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

class Solution
{
	static HashSet<int> PrimeFactor (int n)
	{
		HashSet<int> result = new HashSet<int> ();
		for (int i = 2; i * i <= n; i++) {
			while (n % i == 0) {
				result.Add (i);
				n /= i;
			}
		}
		if (n > 1)
			result.Add (n);
		return result;
	}

	public static int Solve (List<HashSet<int>> factored)
	{
		if (factored.Count == 0)
			return 0;
		HashSet<int> first = factored [0];

		int result = 1000;
		foreach (int f in first) {
			List<HashSet<int>> newList = factored.Where (fac => !fac.Contains (f)).ToList ();
			result = Math.Min (result, Solve (newList));
		}
		return result + 1;
	}

	public static void Main (string[] args)
	{
		Console.ReadLine ();
		int[] nums = Console.ReadLine ().Split (' ').Select (int.Parse).Distinct ().ToArray ();

		List<HashSet<int>> factored = nums.Select (n => PrimeFactor (n)).ToList ();
		factored = factored.OrderBy (f => f.Count).ToList ();
		Console.WriteLine (Solve (factored));
	}
}

using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Text;

class Solution
{
	static bool IsPrime (long n)
	{
		if (n < 2)
			return false;
		for (long i = 2; i * i <= n; i++) {
			if (n % i == 0)
				return false;
		}
		return true;
	}

	public static void Main (string[] args)
	{
		Console.ReadLine ();
		List<int> nums = Console.ReadLine ().Split (' ').Select (int.Parse).Distinct ().ToList ();

		List<int> primeInput = nums.Where (n => IsPrime (n)).ToList ();
		nums = nums.Where (n => !primeInput.Any (p => n % p == 0)).ToList ();
		List<int> primes = Enumerable.Range (1, 100).Where (p => nums.Any (n => n % p == 0)).ToList ();

		bool[,] isDivisible = new bool[nums.Count, primes.Count];
		for (int i = 0; i < nums.Count; i++) {
			for (int idx = 0; idx < primes.Count; idx++) {
				isDivisible [i, idx] = nums [i] % primes [idx] == 0;
			}
		}

		int result = 1 + primes.Count;
		for (int i = 0; i < 1 << primes.Count; i++) {
			int bitCount = 0;
			int tmp = i;
			int index = 0;
			bool[] match = new bool[nums.Count];
			while (tmp > 0) {
				if (tmp % 2 == 1) {
					bitCount++;
					for (int k = 0; k < match.Length; k++) {
						match [k] |= isDivisible [k, index];
					}
				}
				tmp /= 2;
				index++;
			}
			if (bitCount >= result)
				continue;

			bool valid = true;
			foreach (bool b in match)
				valid &= b;
			if (valid)
				result = bitCount;
		}

		Console.WriteLine (result + primeInput.Count);
	}
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Problem
{
    class Program
    {
        static void Main(string[] args)
        {
            int loop = int.Parse(Console.ReadLine());
            int[] arr = new int[loop];
            var res = 0;
            var input = Console.ReadLine().Split(' ');
            for (int i = 0; i < loop; i++)
            {
                arr[i] = int.Parse(input[i]);
            }
            var distinctArr = arr.Distinct().ToArray();
            Array.Sort(arr);
            Array.Sort(distinctArr);

            for (int i = 0; i < distinctArr.Length; i++)
            {
                if (!arr.Contains(distinctArr[i]))
                    continue;
                for (int j = 0; j < arr.Length; j++)
                {
                    if (arr[j] % distinctArr[i] == 0)
                    {
                        arr = arr.Where(val => val != arr[j]).ToArray();
                    }
                }

                res++;
                if (arr.Length == 0)
                    break;

            }
            Console.WriteLine(res);
        }
    }
}