You are given a sequence of integers $$$a_1, a_2, \dots, a_n$$$. You need to paint elements in colors, so that:   If we consider any color, all elements of this color must be divisible by the minimal element of this color.  The number of used colors must be minimized. For example, it's fine to paint elements $$$[40, 10, 60]$$$ in a single color, because they are all divisible by $$$10$$$. You can use any color an arbitrary amount of times (in particular, it is allowed to use a color only once). The elements painted in one color do not need to be consecutive.For example, if $$$a=[6, 2, 3, 4, 12]$$$ then two colors are required: let's paint $$$6$$$, $$$3$$$ and $$$12$$$ in the first color ($$$6$$$, $$$3$$$ and $$$12$$$ are divisible by $$$3$$$) and paint $$$2$$$ and $$$4$$$ in the second color ($$$2$$$ and $$$4$$$ are divisible by $$$2$$$). For example, if $$$a=[10, 7, 15]$$$ then $$$3$$$ colors are required (we can simply paint each element in an unique color).

The first line contains an integer $$$n$$$ ($$$1 \le n \le 100$$$), where $$$n$$$ is the length of the given sequence. The second line contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 100$$$). These numbers can contain duplicates.

Print the minimal number of colors to paint all the given numbers in a valid way.

NoteIn the first example, one possible way to paint the elements in $$$3$$$ colors is:  paint in the first color the elements: $$$a_1=10$$$ and $$$a_4=5$$$,  paint in the second color the element $$$a_3=3$$$,  paint in the third color the elements: $$$a_2=2$$$, $$$a_5=4$$$ and $$$a_6=2$$$. In the second example, you can use one color to paint all the elements.In the third example, one possible way to paint the elements in $$$4$$$ colors is:  paint in the first color the elements: $$$a_4=4$$$, $$$a_6=2$$$ and $$$a_7=2$$$,  paint in the second color the elements: $$$a_2=6$$$, $$$a_5=3$$$ and $$$a_8=3$$$,  paint in the third color the element $$$a_3=5$$$,  paint in the fourth color the element $$$a_1=7$$$.

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.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;
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);
        }
    }
}