Polycarp has $$$n$$$ coins, the value of the $$$i$$$-th coin is $$$a_i$$$. Polycarp wants to distribute all the coins between his pockets, but he cannot put two coins with the same value into the same pocket.For example, if Polycarp has got six coins represented as an array $$$a = [1, 2, 4, 3, 3, 2]$$$, he can distribute the coins into two pockets as follows: $$$[1, 2, 3], [2, 3, 4]$$$.Polycarp wants to distribute all the coins with the minimum number of used pockets. Help him to do that.

The first line of the input contains one integer $$$n$$$ ($$$1 \le n \le 100$$$) — the number of coins. The second line of the input contains $$$n$$$ integers $$$a_1, a_2, \dots, a_n$$$ ($$$1 \le a_i \le 100$$$) — values of coins.

Print only one integer — the minimum number of pockets Polycarp needs to distribute all the coins so no two coins with the same value are put into the same pocket.

import java.util.*;
public class file {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);

		int n = s.nextInt();
		int[] array = new int[101];
		for(int i = 1 ; i<=n ; i++) {
			int temp = s.nextInt();
			array[temp]++;
		}
		Arrays.sort(array);
		System.out.println(array[100]);
	}

}

import java.util.*;
public class cf_1003_a
{
	public static void main(String args[])
	{
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int a[] = new int[n];
		ArrayList<Integer> al = new ArrayList<>();

		for(int i=0;i<n;i++)
		{
			a[i] = sc.nextInt();
		}

		for(int i=0;i<n;i++)
		{
			int count = 0;
			for(int j=0;j<n;j++)
			{
				if(a[i] == a[j])
				{
					count++;
				}
			}
			al.add(count);
		}
		int ans = Collections.max(al);
		System.out.println(ans);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Hashtable;
import java.util.Random;
import java.util.StringTokenizer;

public class ProblemB {
	public static void main(String [] args) throws IOException{
		solve();	}

	public static void solve() throws IOException {
		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		int arr [] = new int[101];
		for(int i=0;i<n;i++) {
			arr[sc.nextInt()]++;
		}
		int max=0;
		for(int i=0;i<arr.length;i++) {
			if(arr[i]>max) {
				max=arr[i];
			}
		}
		System.out.println(max);
	}
	static void shuffle(int[] a)
	{
		int n = a.length;
		for(int i = 0; i < n; i++)
		{
			int r = i + (int)(Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
	}
	static class Pair{
		int start;
		int end;
		public Pair(int s,int e) {
			start=s;
			end=e;
		}
	}

	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){
			br = new BufferedReader(new InputStreamReader(s));
		}

		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if(x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for(int i = start; i < x.length(); i++)
				if(x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				}
				else
				{
					sb.append(x.charAt(i));
					if(dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg?-1:1);
		}

		public boolean ready() throws IOException {return br.ready();}
	}

}

import java.util.LinkedList;
import java.util.Scanner;

public class Main{
	public static void main(String agrs[]) {
		Scanner in = new Scanner(System.in);
		while(in.hasNext()) {
			LinkedList<Integer> num = new LinkedList<>();
			int n = in.nextInt();
			for(int i=0;i<n;i++) {
			 num.add(in.nextInt());
			}
			int nu1=0;
			int nu2=0;
			int finda,findb;
			for(int a=0;a<num.size();a++) {
				nu1 = 0;
				for(int b=a;b<num.size();b++) {
					finda = num.get(a);
					findb = num.get(b);
					if(finda == findb)
						nu1 = nu1 + 1;
					if(nu1 >= nu2 )
						nu2 = nu1;
				}
			}
			System.out.println(nu2);
		}
	}
}

//package basicjava;
import java.io.*;
import java.util.*;
import java.util.Scanner;
public class Main {
    public static void main(String[] args){
        Scanner Sc = new Scanner(System.in);
        int[] arr = new int[101];
        int t=Sc.nextInt();
        int m=0;
        while(t>0){
            int x=Sc.nextInt();
            ++arr[x];
            if(arr[x]>m)
                m=arr[x];
            --t;
        }
        System.out.println(m);
    }
}

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;
import java.util.LinkedList;
import java.util.List;

public class Main {

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int n;
        n = sc.nextInt();
        int arr[] = new int[n];
        for (int i = 0; i < n; i++)
            arr[i] = sc.nextInt();
        Arrays.sort(arr);
        int max = 1;
        for (int i = 0; i < n ; i++) {
            int j=i+1;
            int count=1;
            while(true)
            {
                if(j==arr.length)
                    break;
                if (arr[i] == arr[j])
                {
                    count++;
                    j++;
                }
                else
                    break;

            }
            if(count>max)
                max=count;

        }

        System.out.println(max);
    }
}

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.lang.Math;

public class Main{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt(), coins[] = new int[101];
		for(int i = 0; i< t; i++) {
			int x = sc.nextInt();
			coins[x] = coins[x] + 1;
		}
		int m = 0;
		for(int i = 0; i<101; i++) {
			m = Math.max(m,  coins[i]);
		}
		System.out.println(m);
		sc.close();
	}
}

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;
import java.util.LinkedList;
import java.util.List;

public class Main {

    public static void main(String args[]) throws IOException {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();

        int arr[] = new int[n];

        for(int i = 0; i < n; i++) {
            arr[i] = scanner.nextInt();
        }

        Arrays.sort(arr);

        int maxCount = 1;
        for(int i = 0; i < n; i++) {
            int count = 1;
            int j = i + 1;
            while(true) {
                if(j == arr.length) {
                    break;
                }
                if(arr[i] == arr[j]) {
                    count++;
                    j++;
                }
                else{
                    break;
                }
            }
            if(count > maxCount) {
                maxCount = count;
            }
        }
        System.out.println(maxCount);

    }
}

import java.util.*;
import java.lang.*;
public class Main {
    public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
		for(int i=0;i<n;i++)
		{
		    int x = sc.nextInt();
		    if(map.containsKey(x))
		        map.put(x,map.get(x)+1);
		    else
		        map.put(x,1);
		}
		int ans = -1;
		for(int i:map.keySet())
		    ans = Math.max(map.get(i),ans);
		System.out.println(ans);
    }
}

import java.util.ArrayList;
import java.util.Scanner;

public class John {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n=sc.nextInt();
        int t=0;
        int no=0;
        ArrayList<Integer> c = new ArrayList<Integer>();
        ArrayList<Integer> num = new ArrayList<Integer>();
        for(int i=0;i<n;i++){
            t=sc.nextInt();
            if(!c.contains(t)){
                c.add(t);
                num.add(1);
            }
            else {
                num.set(c.indexOf(t),num.get(c.indexOf(t))+1);
            }
        }
        for (int i=0;i<num.size();i++){
            if(num.get(i)>no){
                no=num.get(i);
            }
        }
        System.out.println(no);

    }
}

import java.util.Scanner;

public class PolycarpsPockets2 {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int[] a = new int[n];

		for(int i=0;i<n;i++)
		{
			a[i]=scan.nextInt();
		}
		int temp = 0,max=0;
		for(int i=0;i<n;i++)
		{
			temp=0;
			for(int j=0;j<n;j++)
			{
				if(a[i]==a[j])
				{
					temp++;
				}
			}
			if(temp>max)
			{
			max=temp;
			}
		}
		System.out.println(max);

	}
}

import java.io.*;
import java.util.*;
import java.util.stream.IntStream;

import static java.lang.Math.*;
import static java.util.Arrays.*;

@SuppressWarnings("ALL")
public class PolycarpPockets {
    public static void main(String[] $) throws IOException {
        PolycarpPockets o = new PolycarpPockets();
        o.main();
        out.flush();
        out.close();
    }

    void main() throws IOException {
        int N = in.ri();
        int[] a = in.ria(N);
        int[] freq = new int[101];
        Arrays.fill(freq, 0);
        int max = -1;
        for (int i = 0; i < N; i++) {
            freq[a[i]]++;
            if (freq[a[i]] > max) max = freq[a[i]];
        }
        out.prln(max);
    }

    static BufferedReader __in = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter __out = new PrintWriter(new OutputStreamWriter(System.out));
    static StringTokenizer input;
    static Random __rand = new Random();
    // constants
    static final int IBIG = 1000000007;
    static final int IMAX = 2147483647;
    static final int IMIN = -2147483648;
    static final long LMAX = 9223372036854775807L;
    static final long LMIN = -9223372036854775808L;

    //Fast Reader Class
    /*static class FastReader {
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new
                    InputStreamReader(System.in));
        }

        String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }

        String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }*/

    //Input fxs
    static class in {
        // input
        static void r() throws IOException {
            input = new StringTokenizer(rline());
        }

        static int ri() throws IOException {
            return Integer.parseInt(rline());
        }

        static long rl() throws IOException {
            return Long.parseLong(rline());
        }

        static double rd() throws IOException {
            return Double.parseDouble(rline());
        }

        static int[] ria(int n) throws IOException {
            int[] a = new int[n];
            r();
            for (int i = 0; i < n; ++i) a[i] = ni();
            return a;
        }

        static int[] riam1(int n) throws IOException {
            int[] a = new int[n];
            r();
            for (int i = 0; i < n; ++i) a[i] = ni() - 1;
            return a;
        }

        static long[] ria1i(long n) throws IOException {
            long[] a = new long[(int) n + 1];
            r();
            for (int i = 1; i <= n; i++) a[i] = nl();
            return a;
        }

        static long[] rla(int n) throws IOException {
            long[] a = new long[n];
            r();
            for (int i = 0; i < n; ++i) a[i] = nl();
            return a;
        }

        static double[] rda(int n) throws IOException {
            double[] a = new double[n];
            r();
            for (int i = 0; i < n; ++i) a[i] = nd();
            return a;
        }

        static char[] rcha() throws IOException {
            return rline().toCharArray();
        }

        static ArrayList<Integer> riaa(int n) throws IOException {
            ArrayList<Integer> a = new ArrayList<>();
            r();
            for (int i = 0; i < n; i++) a.add(ni());
            return a;
        }

        static String rline() throws IOException {
            return __in.readLine();
        }

        static String n() {
            return input.nextToken();
        }

        static int rni() throws IOException {
            r();
            return ni();
        }

        static int ni() {
            return Integer.parseInt(n());
        }

        static long rnl() throws IOException {
            r();
            return nl();
        }

        static long nl() {
            return Long.parseLong(n());
        }

        static double rnd() throws IOException {
            r();
            return nd();
        }

        static double nd() {
            return Double.parseDouble(n());
        }

        static List<List<Integer>> rg(int n, int m) throws IOException {
            List<List<Integer>> g = GR.g(n);
            for (int i = 0; i < m; ++i) GR.c(g, rni() - 1, ni() - 1);
            return g;
        }

        static void rg(List<List<Integer>> g, int m) throws IOException {
            for (int i = 0; i < m; ++i) GR.c(g, rni() - 1, ni() - 1);
        }

        static List<List<Integer>> rdg(int n, int m) throws IOException {
            List<List<Integer>> g = GR.g(n);
            for (int i = 0; i < m; ++i) GR.cto(g, rni() - 1, ni() - 1);
            return g;
        }

        static void rdg(List<List<Integer>> g, int m) throws IOException {
            for (int i = 0; i < m; ++i) GR.cto(g, rni() - 1, ni() - 1);
        }

        static List<Set<Integer>> rsg(int n, int m) throws IOException {
            List<Set<Integer>> g = GR.sg(n);
            for (int i = 0; i < m; ++i) GR.c(g, rni() - 1, ni() - 1);
            return g;
        }

        static void rsg(List<Set<Integer>> g, int m) throws IOException {
            for (int i = 0; i < m; ++i) GR.c(g, rni() - 1, ni() - 1);
        }

        static List<Set<Integer>> rdsg(int n, int m) throws IOException {
            List<Set<Integer>> g = GR.sg(n);
            for (int i = 0; i < m; ++i) GR.cto(g, rni() - 1, ni() - 1);
            return g;
        }

        static void rdsg(List<Set<Integer>> g, int m) throws IOException {
            for (int i = 0; i < m; ++i) GR.cto(g, rni() - 1, ni() - 1);
        }

        static int[][] rim(int n, int m) throws IOException {
            int[][] a = new int[n][m];
            for (int i = 0; i < n; i++) {
                in.r();
                for (int j = 0; j < m; j++) {
                    a[i][j] = in.ni();
                }
            }
            return a;
        }
    }

    //Output fxs
    static class out {
        // output
        static void pr(int i) {
            __out.print(i);
        }

        static void prln(int i) {
            __out.println(i);
        }

        static void pr(long l) {
            __out.print(l);
        }

        static void prln(long l) {
            __out.println(l);
        }

        static void pr(double d) {
            __out.print(d);
        }

        static void prln(double d) {
            __out.println(d);
        }

        static void pr(char c) {
            __out.print(c);
        }

        static void prln(char c) {
            __out.println(c);
        }

        static void pr(char[] s) {
            __out.print(new String(s));
        }

        static void prln(char[] s) {
            __out.println(new String(s));
        }

        static void pr(String s) {
            __out.print(s);
        }

        static void prln(String s) {
            __out.println(s);
        }

        static void pr(Object o) {
            __out.print(o);
        }

        static void prln(Object o) {
            __out.println(o);
        }

        static void prln() {
            __out.println();
        }

        static void pryes() {
            prln("yes");
        }

        static void pry() {
            prln("Yes");
        }

        static void prY() {
            prln("YES");
        }

        static void prno() {
            prln("no");
        }

        static void prn() {
            prln("No");
        }

        static void prN() {
            prln("NO");
        }

        static void pryesno(boolean b) {
            prln(b ? "yes" : "no");
        }

        ;

        static void pryn(boolean b) {
            prln(b ? "Yes" : "No");
        }

        static void prYN(boolean b) {
            prln(b ? "YES" : "NO");
        }

        static void prln(int... a) {
            for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i) ;
            if (a.length > 0) prln(a[a.length - 1]);
            else prln();
        }

        static void prln(long... a) {
            for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i) ;
            if (a.length > 0) prln(a[a.length - 1]);
            else prln();
        }

        static void prln(double... a) {
            for (int i = 0, len = a.length - 1; i < len; pr(a[i]), pr(' '), ++i) ;
            if (a.length > 0) prln(a[a.length - 1]);
            else prln();
        }

        static <T> void prln(Collection<T> c) {
            int n = c.size() - 1;
            Iterator<T> iter = c.iterator();
            for (int i = 0; i < n; pr(iter.next()), pr(' '), ++i) ;
            if (n >= 0) prln(iter.next());
            else prln();
        }

        static void h() {
            prln("hlfd");
            flush();
        }

        static void flush() {
            __out.flush();
        }

        static void close() {
            __out.close();
        }

        static void prM(int[][] a, int n, int m) {
            for (int i = 0; i < m; i++) {
                for (int j = 0; j < n; j++)
                    out.pr(a[i][j] + " ");
                out.prln();
            }
        }
    }

    //Math fxs
    static class mathx {
        // math util
        static int minof(int a, int b, int c) {
            return min(a, min(b, c));
        }

        static int minof(int... x) {
            if (x.length == 1) return x[0];
            if (x.length == 2) return min(x[0], x[1]);
            if (x.length == 3) return min(x[0], min(x[1], x[2]));
            int min = x[0];
            for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i];
            return min;
        }

        static long minof(long a, long b, long c) {
            return min(a, min(b, c));
        }

        static long minof(long... x) {
            if (x.length == 1) return x[0];
            if (x.length == 2) return min(x[0], x[1]);
            if (x.length == 3) return min(x[0], min(x[1], x[2]));
            long min = x[0];
            for (int i = 1; i < x.length; ++i) if (x[i] < min) min = x[i];
            return min;
        }

        static int maxof(int a, int b, int c) {
            return max(a, max(b, c));
        }

        static int maxof(int... x) {
            if (x.length == 1) return x[0];
            if (x.length == 2) return max(x[0], x[1]);
            if (x.length == 3) return max(x[0], max(x[1], x[2]));
            int max = x[0];
            for (int i = 1; i < x.length; ++i) if (x[i] > max) max = x[i];
            return max;
        }

        static long maxof(long a, long b, long c) {
            return max(a, max(b, c));
        }

        static long maxof(long... x) {
            if (x.length == 1) return x[0];
            if (x.length == 2) return max(x[0], x[1]);
            if (x.length == 3) return max(x[0], max(x[1], x[2]));
            long max = x[0];
            for (int i = 1; i < x.length; ++i) if (x[i] > max) max = x[i];
            return max;
        }

        static int powi(int a, int b) {
            if (a == 0) return 0;
            int ans = 1;
            while (b > 0) {
                if ((b & 1) > 0) ans *= a;
                a *= a;
                b >>= 1;
            }
            return ans;
        }

        static long powl(long a, int b) {
            if (a == 0) return 0;
            long ans = 1;
            while (b > 0) {
                if ((b & 1) > 0) ans *= a;
                a *= a;
                b >>= 1;
            }
            return ans;
        }

        static int fli(double d) {
            return (int) d;
        }

        static int cei(double d) {
            return (int) ceil(d);
        }

        static long fll(double d) {
            return (long) d;
        }

        static long cel(double d) {
            return (long) ceil(d);
        }

        static int gcf(int a, int b) {
            return b == 0 ? a : gcf(b, a % b);
        }

        static long gcf(long a, long b) {
            return b == 0 ? a : gcf(b, a % b);
        }

        static int lcm(int a, int b) {
            return a * b / gcf(a, b);
        }

        static long lcm(long a, long b) {
            return a * b / gcf(a, b);
        }

        static int randInt(int min, int max) {
            return __rand.nextInt(max - min + 1) + min;
        }

        static long mix(long x) {
            x += 0x9e3779b97f4a7c15L;
            x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9L;
            x = (x ^ (x >> 27)) * 0x94d049bb133111ebL;
            return x ^ (x >> 31);
        }
    }

    //Array fxs
    static class ARR {
        // array util
        static void reverse(int[] a) {
            for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {
                int swap = a[i];
                a[i] = a[n - i - 1];
                a[n - i - 1] = swap;
            }
        }

        static void reverse(long[] a) {
            for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {
                long swap = a[i];
                a[i] = a[n - i - 1];
                a[n - i - 1] = swap;
            }
        }

        static void reverse(double[] a) {
            for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {
                double swap = a[i];
                a[i] = a[n - i - 1];
                a[n - i - 1] = swap;
            }
        }

        static void reverse(char[] a) {
            for (int i = 0, n = a.length, half = n / 2; i < half; ++i) {
                char swap = a[i];
                a[i] = a[n - i - 1];
                a[n - i - 1] = swap;
            }
        }

        static void shuffle(int[] a) {
            int n = a.length - 1;
            for (int i = 0; i < n; ++i) {
                int ind = mathx.randInt(i, n);
                int swap = a[i];
                a[i] = a[ind];
                a[ind] = swap;
            }
        }

        static void shuffle(long[] a) {
            int n = a.length - 1;
            for (int i = 0; i < n; ++i) {
                int ind = mathx.randInt(i, n);
                long swap = a[i];
                a[i] = a[ind];
                a[ind] = swap;
            }
        }

        static void shuffle(double[] a) {
            int n = a.length - 1;
            for (int i = 0; i < n; ++i) {
                int ind = mathx.randInt(i, n);
                double swap = a[i];
                a[i] = a[ind];
                a[ind] = swap;
            }
        }

        static void rsort(int[] a) {
            shuffle(a);
            sort(a);
        }

        static void rsort(long[] a) {
            shuffle(a);
            sort(a);
        }

        static void rsort(double[] a) {
            shuffle(a);
            sort(a);
        }

        static int[] copy(int[] a) {
            int[] ans = new int[a.length];
            System.arraycopy(a, 0, ans, 0, a.length);
            return ans;
        }

        static long[] copy(long[] a) {
            long[] ans = new long[a.length];
            System.arraycopy(a, 0, ans, 0, a.length);
            return ans;
        }

        static double[] copy(double[] a) {
            double[] ans = new double[a.length];
            System.arraycopy(a, 0, ans, 0, a.length);
            return ans;
        }

        static char[] copy(char[] a) {
            char[] ans = new char[a.length];
            System.arraycopy(a, 0, ans, 0, a.length);
            return ans;
        }
    }

    //Graph fxs
    static class GR {
        // graph util
        static List<List<Integer>> g(int n) {
            List<List<Integer>> g = new ArrayList<>();
            for (int i = 0; i < n; ++i) g.add(new ArrayList<>());
            return g;
        }

        static List<Set<Integer>> sg(int n) {
            List<Set<Integer>> g = new ArrayList<>();
            for (int i = 0; i < n; ++i) g.add(new HashSet<>());
            return g;
        }

        static void c(List<? extends Collection<Integer>> g, int u, int v) {
            g.get(u).add(v);
            g.get(v).add(u);
        }

        static void cto(List<? extends Collection<Integer>> g, int u, int v) {
            g.get(u).add(v);
        }

        static void dc(List<? extends Collection<Integer>> g, int u, int v) {
            g.get(u).remove(v);
            g.get(v).remove(u);
        }

        static void dcto(List<? extends Collection<Integer>> g, int u, int v) {
            g.get(u).remove(v);
        }
    }

    //Utilsx class
    static class utilX {
        static int[] subsetSum(int[] nums) {
            int M = IntStream.of(nums).sum();
            int[] m = new int[M + 10];
            for (int i = 0; i < M + 10; i++) m[i] = 0;
            m[0] = 1;
            for (int num : nums) {
                for (int j = M; j >= num; j--) {
                    m[j] |= m[j - num];
                }
            }
            return m;
        }

        static int LIS(int[] nums) {
            int[] m = new int[nums.length];
            for (int i = nums.length - 1; i >= 0; i--) {
                m[i] = 1;
                for (int j = i + 1; j < nums.length; j++) {
                    if (nums[j] > nums[i]) {
                        m[i] = max(m[i], m[j] + 1);
                    }
                }
            }
            int ans = 0;
            for (int i = 0; i < nums.length; i++) {
                ans = max(ans, m[i]);
            }
            return ans;
        }
    }

    //Pair Class
    static class Pair<F, S> {
        public final F first;
        public final S second;

        public Pair(F first, S second) {
            this.first = first;
            this.second = second;
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Pair)) {
                return false;
            }
            Pair<?, ?> p = (Pair<?, ?>) o;
            return Objects.equals(p.first, first) && Objects.equals(p.second, second);
        }
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Polycarps_Pockets {

	public static void main(String[] args) {
		Scanner t = new Scanner(System.in);

		int n = t.nextInt();
		int[] a = new int[n];
		int cur = 1, max = 1;

		for (int i = 0; i < n; i++)
			a[i] = t.nextInt();

		Arrays.sort(a);

		for (int i = 0; i < n - 1; i++) {
			if (a[i] == a[i + 1])
				cur++;
			else {
				if (max < cur)
					max = cur;
				cur = 1;
			}
		}

		if (a.length != 1 && a[n - 2] == a[n - 1]) {
			if (max < cur)
				max = cur;
		}

		System.out.println(max);
	}

}

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;
public class Polycarps_pocket {
    public static void main(String args[])
    {
        Scanner sc = new Scanner(System.in);
        ArrayList<Integer> li = new ArrayList<>();
        int no = sc.nextInt();
        int occurance = 0;
        for(int i=0;i<no;i++)
        {
            int val = sc.nextInt();
            li.add(val);
        }
        for(int i:li)
        {
            int ans = Collections.frequency(li,i);
            occurance = Math.max(ans,occurance);
        }
        System.out.println(occurance);
    }
}

// practice with kaiboy
import java.io.*;
import java.util.*;

public class CF1003A extends PrintWriter {
	CF1003A() { super(System.out, true); }
	Scanner sc = new Scanner(System.in);
	public static void main(String[] $) {
		CF1003A o = new CF1003A(); o.main(); o.flush();
	}

	static final int A = 100;
	void main() {
		int n = sc.nextInt();
		int[] kk = new int[A + 1];
		int ans = 0;
		while (n-- > 0) {
			int a = sc.nextInt();
			ans = Math.max(ans, ++kk[a]);
		}
		println(ans);
	}
}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int n = scanner.nextInt();
        int[] ar = new int[1000];
        int[] maxFind = new int[1000];
        int max = 0;
        for (int i = 0; i < n; i++) {
            int a = scanner.nextInt();
            ar[i] = a;
            maxFind[ar[i]]++;
            max = Math.max(max,maxFind[ar[i]]);
        }
        System.out.println(max);
    }
}

import java.io.*;
import java.lang.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        Input input = new Input();
        Output output = new Output();
        int quantity = input.ReadInt();
        int [] base = FastSort.SortWithReturn(input.ReadArrayInt(" " ), -1, quantity);
        int pred = base[0];
        int count = 1;
        int answer = 1;
        for (int index = 1 ; index < quantity; index++){
            if (base[index] == pred){
                count++;
            }else{
                if (answer < count){
                    answer = count;
                }
                count = 1;
            }
            pred = base[index];
        }
        System.out.println(count > answer ? count : answer);
    }
}

class method {

    public static int gcd(int a, int b) { // NOD
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static int lcm(int a, int b) { // NOK
        return a / gcd(a, b) * b;
    }

    public static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    public static int TwoToTen(String number, Integer length) {
        if (length == null){
            length = number.length();
        }
        char[] chars = number.toCharArray();
        int result = 0;
        int mult = 1;
        for (int i = length - 1; i >= 0; i--) {
            if (chars[i] == '1') {
                result += mult;
            }
            mult *= 2;
        }
        return result;
    }

    public static String TenToTwo(int number) {
        if (number == 0) {
            return "0";
        }
        StringBuilder result = new StringBuilder();
        while (number != 0) {
            result.append(number & 1);
            number >>>= 1;
        }
        return result.reverse().toString();
    }
}

class FastSort {

    public static void SortWithoutReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
    }

    public static int[] SortWithReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
        return array;
    }

    private static void sort(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        Random random = new Random();
        if (ShellHeapMergeMyInsertionSort < 0 || ShellHeapMergeMyInsertionSort > 4) {
            ShellHeapMergeMyInsertionSort = random.nextInt(4);
        }
        if (ShellHeapMergeMyInsertionSort == 0) {
            ShellSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 1) {
            HeapSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 2) {
            MergeSort(array, 0, length - 1);
        } else if (ShellHeapMergeMyInsertionSort == 3) {
            StraightMergerSort(array, length);
        } else if (ShellHeapMergeMyInsertionSort == 4) {
            insertionSort(array);
        }
    }

    private static void StraightMergerSort(int[] array, int size) {
        if (size == 0) {
            return;
        }
        int length = (size / 2) + ((size % 2) == 0 ? 0 : 1);
        Integer[][] ZeroBuffer = new Integer[length + length % 2][2];
        Integer[][] FirstBuffer = new Integer[0][0];
        for (int index = 0; index < length; index++) {
            int ArrayIndex = index * 2;
            int NextArrayIndex = index * 2 + 1;
            if (NextArrayIndex < size) {
                if (array[ArrayIndex] > array[NextArrayIndex]) {
                    ZeroBuffer[index][0] = array[NextArrayIndex];
                    ZeroBuffer[index][1] = array[ArrayIndex];
                } else {
                    ZeroBuffer[index][0] = array[ArrayIndex];
                    ZeroBuffer[index][1] = array[NextArrayIndex];
                }
            } else {
                ZeroBuffer[index][0] = array[ArrayIndex];
            }
        }
        boolean position = false;
        int pointer0;
        int pointer;
        int pointer1;
        int number = 4;
        int NewPointer;
        int count;
        Integer[][] NewBuffer;
        Integer[][] OldBuffer;
        length = (size / 4) + ((size % 4) == 0 ? 0 : 1);
        while (true) {
            pointer0 = 0;
            count = (number / 2) - 1;
            if (!position) {
                FirstBuffer = new Integer[length + length % 2][number];
                NewBuffer = FirstBuffer;
                OldBuffer = ZeroBuffer;
            } else {
                ZeroBuffer = new Integer[length + length % 2][number];
                NewBuffer = ZeroBuffer;
                OldBuffer = FirstBuffer;
            }
            for (int i = 0; i < length; i++) {
                pointer = 0;
                pointer1 = 0;
                NewPointer = pointer0 + 1;
                if (length == 1) {
                    for (int g = 0; g < size; g++) {
                        if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                            if (OldBuffer[pointer0][pointer] == null) {
                                continue;
                            }
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else {
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        }
                    }
                    return;
                }
                for (int g = 0; g < number; g++) {
                    if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                        if (OldBuffer[NewPointer][pointer1] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                        if (OldBuffer[pointer0][pointer] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else {
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    }
                }
                pointer0 += 2;
            }
            position = !position;
            length = length / 2 + (length % 2 == 0 ? 0 : 1);
            number *= 2;

        }
    }

    public static void ShellSort(int[] array) {
        int j;
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                int temp = array[i];
                for (j = i; j >= gap && array[j - gap] > temp; j -= gap) {
                    array[j] = array[j - gap];
                }
                array[j] = temp;
            }
        }
    }

    private static void HeapSort(int[] array) {
        for (int i = array.length / 2 - 1; i >= 0; i--)
            shiftDown(array, i, array.length);
        for (int i = array.length - 1; i > 0; i--) {
            swap(array, 0, i);
            shiftDown(array, 0, i);
        }
    }

    private static void shiftDown(int[] array, int i, int n) {
        int child;
        int tmp;

        for (tmp = array[i]; leftChild(i) < n; i = child) {
            child = leftChild(i);
            if (child != n - 1 && (array[child] < array[child + 1]))
                child++;
            if (tmp < array[child])
                array[i] = array[child];
            else
                break;
        }
        array[i] = tmp;
    }

    private static int leftChild(int i) {
        return 2 * i + 1;
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    private static void MergeSort(int[] array, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            MergeSort(array, low, mid);
            MergeSort(array, mid + 1, high);
            merge(array, low, mid, high);
        }
    }

    private static void merge(int[] array, int low, int mid, int high) {

        int n = high - low + 1;
        int[] Temp = new int[n];

        int i = low, j = mid + 1;
        int k = 0;

        while (i <= mid || j <= high) {
            if (i > mid)
                Temp[k++] = array[j++];
            else if (j > high)
                Temp[k++] = array[i++];
            else if (array[i] < array[j])
                Temp[k++] = array[i++];
            else
                Temp[k++] = array[j++];
        }
        for (j = 0; j < n; j++)
            array[low + j] = Temp[j];
    }

    private static void insertionSort(int[] elements) {
        for (int i = 1; i < elements.length; i++) {
            int key = elements[i];
            int j = i - 1;
            while (j >= 0 && key < elements[j]) {
                elements[j + 1] = elements[j];
                j--;
            }
            elements[j + 1] = key;
        }
    }
}

class Input {

    private BufferedReader input;

    Input() {
        input = new BufferedReader(new InputStreamReader(System.in));
    }

    public int ReadInt() throws Exception {
        return Integer.parseInt(input.readLine());
    }

    public long ReadLong() throws Exception {
        return Long.parseLong(input.readLine());
    }

    public String ReadString() throws Exception {
        return input.readLine();
    }

    public int[] ReadArrayInt(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToInt(Integer::parseInt).toArray();
    }

    public long[] ReadArrayLong(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToLong(Long::parseLong).toArray();
    }

    public String[] ReadArrayString(String split) throws Exception {
        return input.readLine().split(split);
    }
}

class Output {
    public void WriteArray(int[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(long[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(String[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }
}

import java.util.*;
import java.io.*;

public class Solution{

    public static void main(String[] args) throws Exception{

        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        String[] str = br.readLine().split(" ");
        HashMap<String,Integer> set = new HashMap<>();

        int p = 1;
        for(int i=0;i<str.length;++i){
            String ch = str[i];
            if(!set.containsKey(ch)){
                set.put(ch,1);
            }
            else{
                set.put(ch,set.get(ch)+1);
                p = Math.max(p,set.get(ch));
            }
        }

        System.out.println(p);
    }
}

import java.io.*;
import java.math.BigInteger;
import java.util.*;

public class Main {

	static long sx = 0, sy = 0, mod = (long) (1e9 + 7);

	static ArrayList<Integer>[] a;
	// static ArrayList<pair> p;
	static int[][] dp;
	static long[] fa;
	static int[] farr;
	public static PrintWriter out = new PrintWriter(System.out);
	static ArrayList<pair> pa = new ArrayList<>();
	static long[] fact = new long[(int) 1e6];
	static StringBuilder sb = new StringBuilder();
	static boolean cycle = false;
	// static long m = 998244353;
	static int[] no, col;
	static int m = 0, n = 0, q;
	static int[] ans;
	static long[] p;
	static int[] time;
	static TreeMap<Long, Integer> hm = new TreeMap<>();

	public static void main(String[] args) throws IOException {

		// Scanner scn = new Scanner(new BufferedReader(new
		// InputStreamReader(System.in)));

		Reader scn = new Reader();

		 int n = scn.nextInt();

		 HashMap<Integer, Integer>hm = new HashMap<>();
		 int ans = 0;

		  for(int i=0; i<n; i++){

			  int x = scn.nextInt();
			  hm.put(x, hm.containsKey(x)?hm.get(x)+1:1);
			  ans = Math.max(ans, hm.get(x));
		  }

		  System.out.println(ans);
	}

	// _________________________TEMPLATE_____________________________________________________________

	// public static long lcm(long x, long y) {
	//
	// return (x * y) / gcd(x, y);
	// }
	//
	// private static long gcd(long x, long y) {
	// if (x == 0)
	// return y;
	//
	// return gcd(y % x, x);
	// }
	//
	// static class comp implements Comparator<Integer> {
	//
	// @Override
	// public int compare(Integer p1, Integer p2) {
	//
	// return p2 - p1;
	//
	// }
	// }
	//
	// }
	//
	// public static long pow(long a, long b) {
	//
	// if (b < 0)
	// return 0;
	// if (b == 0 || b == 1)
	// return (long) Math.pow(a, b);
	//
	// if (b % 2 == 0) {
	//
	// long ret = pow(a, b / 2);
	// ret = (ret % mod * ret % mod) % mod;
	// return ret;
	// }
	//
	// else {
	// return ((pow(a, b - 1) % mod) * a % mod) % mod;
	// }
	// }

	private static class pair implements Comparable<pair> {

		int a, b, c, d;

		pair(int p, int q, int r, int s) {

			a = p;
			b = q;
			c = r;
			d = s;

		}

		@Override
		public int compareTo(pair o) {

			return 1;

		}

		// @Override
		//
		// public int hashCode() {
		// return i;
		// }
		//
		// @Override
		//
		// public boolean equals(Object o) {
		//
		// pair p = (pair) o;
		// return this.i == p.i;
		// }

	}

	private static class pair1 {

		int c, t;

		pair1(int a, int b) {
			c = a;
			t = b;
		}
	}

	private static String reverse(String s) {

		return new StringBuilder(s).reverse().toString();
	}

	public static class Reader {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;

		public Reader() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public Reader(String file_name) throws IOException {
			din = new DataInputStream(new FileInputStream(file_name));
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}

		public String readLine() throws IOException {
			byte[] buf = new byte[1000000 + 1]; // line length
			int cnt = 0, c;
			while ((c = read()) != -1) {
				if (c == '\n')
					break;
				buf[cnt++] = (byte) c;
			}
			return new String(buf, 0, cnt);
		}

		public int nextInt() throws IOException {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}

		public long nextLong() throws IOException {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}

		public double nextDouble() throws IOException {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();

			do {
				ret = ret * 10 + c - '0';
			} while ((c = read()) >= '0' && c <= '9');

			if (c == '.') {
				while ((c = read()) >= '0' && c <= '9') {
					ret += (c - '0') / (div *= 10);
				}
			}

			if (neg)
				return -ret;
			return ret;
		}

		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}

		private byte read() throws IOException {
			if (bufferPointer == bytesRead)
				fillBuffer();
			return buffer[bufferPointer++];
		}

		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}

		public int[] nextIntArray(int n) throws IOException {
			int[] arr = new int[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextInt();
			}
			return arr;
		}

		public long[] nextLongArray(int n) throws IOException {
			long[] arr = new long[n];
			for (int i = 0; i < n; i++) {
				arr[i] = nextLong();
			}
			return arr;
		}

		public int[][] nextInt2DArray(int m, int n) throws IOException {
			int[][] arr = new int[m][n];
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++)
					arr[i][j] = nextInt();
			}
			return arr;
		}

		public long[][] nextInt2DArrayL(int m, int n) throws IOException {
			long[][] arr = new long[m][n];
			for (int i = 0; i < m; i++) {
				for (int j = 0; j < n; j++)
					arr[i][j] = nextInt();
			}
			return arr;
		}
		// kickstart - Solution
		// atcoder - Main
	}

}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Polycarp_Pocket {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        HashMap <Integer,Integer> value=new HashMap<>();
        for(int i=0;i<number;i++){
            int input=sc.nextInt();
            if(value.containsKey(input)) {
                value.put(input, value.get(input)+1);
            } else {
                value.put(input, 1);
            }
        }

        int totalPocket = 1;

        for (Map.Entry<Integer, Integer> data: value.entrySet()) {
            if (data.getValue()>totalPocket) {
                totalPocket = data.getValue();
            }
        }

        System.out.println(totalPocket);
    }
}

import java.util.*;
final public class S
{
public static void main(String args[])
{
Scanner src=new Scanner(System.in);
int n=src.nextInt();
int[] a=new int[101];
for(int i=0;i<n;i++)
{
a[src.nextInt()]++;
}
Arrays.sort(a);
System.out.println(a[100]);
}
}

import java.util.Scanner;
import java.util.Arrays;
import java.util.*;
public class pocket
{
    public static void main(String args[])
    {
        Scanner s=new Scanner(System.in);
        int n,c=0,i,j,k=0;
        n=s.nextInt();
        int a[]=new int[n];
        for(i=0;i<n;i++)
        a[i]=s.nextInt();
        for(i=0;i<n;i++)
        {   k=1;
            for(j=i+1;j<n;j++)
            {
            if(a[i]==a[j])
            k++;
            }
            if(k>c)
            {
            c=k;
            k=1;
        }
            }

            System.out.println(c);
        }
    }

// https://codeforces.com/problemset/problem/1003/A

import java.util.Scanner;

public class PolycarpsPockets {

	public static void main(String[] args) {

		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		scanner.nextLine();
		int counter[] = new int[101];
		int temp;
		int ans = 0;

		for (int i = 0; i < n; i++) {
			temp = scanner.nextInt();
			counter[temp] = counter[temp] + 1;
		}

		for (int i = 1; i < counter.length; i++) {
			if (ans < counter[i])
				ans = counter[i];

		}
		System.out.println(ans);

	}

}

import java.io.*;
import java.lang.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        Input input = new Input();
        Output output = new Output();
        int quantity = input.ReadInt();
        int [] base = FastSort.SortWithReturn(input.ReadArrayInt(" " ), 1, quantity);
        int pred = base[0];
        int count = 1;
        int answer = 1;
        for (int index = 1 ; index < quantity; index++){
            if (base[index] == pred){
                count++;
            }else{
                if (answer < count){
                    answer = count;
                }
                count = 1;
            }
            pred = base[index];
        }
        System.out.println(count > answer ? count : answer);
    }
}

class method {

    public static int gcd(int a, int b) { // NOD
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static int lcm(int a, int b) { // NOK
        return a / gcd(a, b) * b;
    }

    public static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    public static int TwoToTen(String number, Integer length) {
        if (length == null){
            length = number.length();
        }
        char[] chars = number.toCharArray();
        int result = 0;
        int mult = 1;
        for (int i = length - 1; i >= 0; i--) {
            if (chars[i] == '1') {
                result += mult;
            }
            mult *= 2;
        }
        return result;
    }

    public static String TenToTwo(int number) {
        if (number == 0) {
            return "0";
        }
        StringBuilder result = new StringBuilder();
        while (number != 0) {
            result.append(number & 1);
            number >>>= 1;
        }
        return result.reverse().toString();
    }
}

class FastSort {

    public static void SortWithoutReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
    }

    public static int[] SortWithReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
        return array;
    }

    private static void sort(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        Random random = new Random();
        if (ShellHeapMergeMyInsertionSort < 0 || ShellHeapMergeMyInsertionSort > 4) {
            ShellHeapMergeMyInsertionSort = random.nextInt(4);
        }
        if (ShellHeapMergeMyInsertionSort == 0) {
            ShellSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 1) {
            HeapSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 2) {
            MergeSort(array, 0, length - 1);
        } else if (ShellHeapMergeMyInsertionSort == 3) {
            StraightMergerSort(array, length);
        } else if (ShellHeapMergeMyInsertionSort == 4) {
            insertionSort(array);
        }
    }

    private static void StraightMergerSort(int[] array, int size) {
        if (size == 0) {
            return;
        }
        int length = (size / 2) + ((size % 2) == 0 ? 0 : 1);
        Integer[][] ZeroBuffer = new Integer[length + length % 2][2];
        Integer[][] FirstBuffer = new Integer[0][0];
        for (int index = 0; index < length; index++) {
            int ArrayIndex = index * 2;
            int NextArrayIndex = index * 2 + 1;
            if (NextArrayIndex < size) {
                if (array[ArrayIndex] > array[NextArrayIndex]) {
                    ZeroBuffer[index][0] = array[NextArrayIndex];
                    ZeroBuffer[index][1] = array[ArrayIndex];
                } else {
                    ZeroBuffer[index][0] = array[ArrayIndex];
                    ZeroBuffer[index][1] = array[NextArrayIndex];
                }
            } else {
                ZeroBuffer[index][0] = array[ArrayIndex];
            }
        }
        boolean position = false;
        int pointer0;
        int pointer;
        int pointer1;
        int number = 4;
        int NewPointer;
        int count;
        Integer[][] NewBuffer;
        Integer[][] OldBuffer;
        length = (size / 4) + ((size % 4) == 0 ? 0 : 1);
        while (true) {
            pointer0 = 0;
            count = (number / 2) - 1;
            if (!position) {
                FirstBuffer = new Integer[length + length % 2][number];
                NewBuffer = FirstBuffer;
                OldBuffer = ZeroBuffer;
            } else {
                ZeroBuffer = new Integer[length + length % 2][number];
                NewBuffer = ZeroBuffer;
                OldBuffer = FirstBuffer;
            }
            for (int i = 0; i < length; i++) {
                pointer = 0;
                pointer1 = 0;
                NewPointer = pointer0 + 1;
                if (length == 1) {
                    for (int g = 0; g < size; g++) {
                        if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                            if (OldBuffer[pointer0][pointer] == null) {
                                continue;
                            }
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else {
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        }
                    }
                    return;
                }
                for (int g = 0; g < number; g++) {
                    if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                        if (OldBuffer[NewPointer][pointer1] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                        if (OldBuffer[pointer0][pointer] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else {
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    }
                }
                pointer0 += 2;
            }
            position = !position;
            length = length / 2 + (length % 2 == 0 ? 0 : 1);
            number *= 2;

        }
    }

    public static void ShellSort(int[] array) {
        int j;
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                int temp = array[i];
                for (j = i; j >= gap && array[j - gap] > temp; j -= gap) {
                    array[j] = array[j - gap];
                }
                array[j] = temp;
            }
        }
    }

    private static void HeapSort(int[] array) {
        for (int i = array.length / 2 - 1; i >= 0; i--)
            shiftDown(array, i, array.length);
        for (int i = array.length - 1; i > 0; i--) {
            swap(array, 0, i);
            shiftDown(array, 0, i);
        }
    }

    private static void shiftDown(int[] array, int i, int n) {
        int child;
        int tmp;

        for (tmp = array[i]; leftChild(i) < n; i = child) {
            child = leftChild(i);
            if (child != n - 1 && (array[child] < array[child + 1]))
                child++;
            if (tmp < array[child])
                array[i] = array[child];
            else
                break;
        }
        array[i] = tmp;
    }

    private static int leftChild(int i) {
        return 2 * i + 1;
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    private static void MergeSort(int[] array, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            MergeSort(array, low, mid);
            MergeSort(array, mid + 1, high);
            merge(array, low, mid, high);
        }
    }

    private static void merge(int[] array, int low, int mid, int high) {

        int n = high - low + 1;
        int[] Temp = new int[n];

        int i = low, j = mid + 1;
        int k = 0;

        while (i <= mid || j <= high) {
            if (i > mid)
                Temp[k++] = array[j++];
            else if (j > high)
                Temp[k++] = array[i++];
            else if (array[i] < array[j])
                Temp[k++] = array[i++];
            else
                Temp[k++] = array[j++];
        }
        for (j = 0; j < n; j++)
            array[low + j] = Temp[j];
    }

    private static void insertionSort(int[] elements) {
        for (int i = 1; i < elements.length; i++) {
            int key = elements[i];
            int j = i - 1;
            while (j >= 0 && key < elements[j]) {
                elements[j + 1] = elements[j];
                j--;
            }
            elements[j + 1] = key;
        }
    }
}

class Input {

    private BufferedReader input;

    Input() {
        input = new BufferedReader(new InputStreamReader(System.in));
    }

    public int ReadInt() throws Exception {
        return Integer.parseInt(input.readLine());
    }

    public long ReadLong() throws Exception {
        return Long.parseLong(input.readLine());
    }

    public String ReadString() throws Exception {
        return input.readLine();
    }

    public int[] ReadArrayInt(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToInt(Integer::parseInt).toArray();
    }

    public long[] ReadArrayLong(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToLong(Long::parseLong).toArray();
    }

    public String[] ReadArrayString(String split) throws Exception {
        return input.readLine().split(split);
    }
}

class Output {
    public void WriteArray(int[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(long[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(String[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }
}

import java.util.*;

public class N {
    public static void main(String[] args){
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int[] arr=new int[100];
        for (int i=0;i<n;i++) {
            arr[scanner.nextInt()-1]++;
        }
        Arrays.sort(arr);
        System.out.println(arr[99]);
    }
}

import java.util.*;
public class file{
    private static Scanner scan;
    public static void main(String args[]){
        scan=new Scanner(System.in);
        int n;
        n=scan.nextInt();
        int i;
        int arr[]=new int[n];
        for(i=0;i<n;i++)
        arr[i]=scan.nextInt();

        int frequency[]=new int[101];
        for(i=0;i<n;i++)
          frequency[arr[i]]++;

          int max=frequency[arr[0]];
          for(i=1;i<n;i++)
          if(frequency[arr[i]]>max)
          max=frequency[arr[i]];

          System.out.println(max);

    }
}

import java.io.*;
import java.lang.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        Input input = new Input();
        Output output = new Output();
        int quantity = input.ReadInt();
        int [] base = FastSort.SortWithReturn(input.ReadArrayInt(" " ), 4, quantity);
        int pred = base[0];
        int count = 1;
        int answer = 1;
        for (int index = 1 ; index < quantity; index++){
            if (base[index] == pred){
                count++;
            }else{
                if (answer < count){
                    answer = count;
                }
                count = 1;
            }
            pred = base[index];
        }
        System.out.println(count > answer ? count : answer);
    }
}

class method {

    public static int gcd(int a, int b) { // NOD
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static int lcm(int a, int b) { // NOK
        return a / gcd(a, b) * b;
    }

    public static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }

    public static int TwoToTen(String number, Integer length) {
        if (length == null){
            length = number.length();
        }
        char[] chars = number.toCharArray();
        int result = 0;
        int mult = 1;
        for (int i = length - 1; i >= 0; i--) {
            if (chars[i] == '1') {
                result += mult;
            }
            mult *= 2;
        }
        return result;
    }

    public static String TenToTwo(int number) {
        if (number == 0) {
            return "0";
        }
        StringBuilder result = new StringBuilder();
        while (number != 0) {
            result.append(number & 1);
            number >>>= 1;
        }
        return result.reverse().toString();
    }
}

class FastSort {

    public static void SortWithoutReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
    }

    public static int[] SortWithReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
        return array;
    }

    private static void sort(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        Random random = new Random();
        if (ShellHeapMergeMyInsertionSort < 0 || ShellHeapMergeMyInsertionSort > 4) {
            ShellHeapMergeMyInsertionSort = random.nextInt(4);
        }
        if (ShellHeapMergeMyInsertionSort == 0) {
            ShellSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 1) {
            HeapSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 2) {
            MergeSort(array, 0, length - 1);
        } else if (ShellHeapMergeMyInsertionSort == 3) {
            StraightMergerSort(array, length);
        } else if (ShellHeapMergeMyInsertionSort == 4) {
            insertionSort(array);
        }
    }

    private static void StraightMergerSort(int[] array, int size) {
        if (size == 0) {
            return;
        }
        int length = (size / 2) + ((size % 2) == 0 ? 0 : 1);
        Integer[][] ZeroBuffer = new Integer[length + length % 2][2];
        Integer[][] FirstBuffer = new Integer[0][0];
        for (int index = 0; index < length; index++) {
            int ArrayIndex = index * 2;
            int NextArrayIndex = index * 2 + 1;
            if (NextArrayIndex < size) {
                if (array[ArrayIndex] > array[NextArrayIndex]) {
                    ZeroBuffer[index][0] = array[NextArrayIndex];
                    ZeroBuffer[index][1] = array[ArrayIndex];
                } else {
                    ZeroBuffer[index][0] = array[ArrayIndex];
                    ZeroBuffer[index][1] = array[NextArrayIndex];
                }
            } else {
                ZeroBuffer[index][0] = array[ArrayIndex];
            }
        }
        boolean position = false;
        int pointer0;
        int pointer;
        int pointer1;
        int number = 4;
        int NewPointer;
        int count;
        Integer[][] NewBuffer;
        Integer[][] OldBuffer;
        length = (size / 4) + ((size % 4) == 0 ? 0 : 1);
        while (true) {
            pointer0 = 0;
            count = (number / 2) - 1;
            if (!position) {
                FirstBuffer = new Integer[length + length % 2][number];
                NewBuffer = FirstBuffer;
                OldBuffer = ZeroBuffer;
            } else {
                ZeroBuffer = new Integer[length + length % 2][number];
                NewBuffer = ZeroBuffer;
                OldBuffer = FirstBuffer;
            }
            for (int i = 0; i < length; i++) {
                pointer = 0;
                pointer1 = 0;
                NewPointer = pointer0 + 1;
                if (length == 1) {
                    for (int g = 0; g < size; g++) {
                        if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                            if (OldBuffer[pointer0][pointer] == null) {
                                continue;
                            }
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else {
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        }
                    }
                    return;
                }
                for (int g = 0; g < number; g++) {
                    if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                        if (OldBuffer[NewPointer][pointer1] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                        if (OldBuffer[pointer0][pointer] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else {
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    }
                }
                pointer0 += 2;
            }
            position = !position;
            length = length / 2 + (length % 2 == 0 ? 0 : 1);
            number *= 2;

        }
    }

    public static void ShellSort(int[] array) {
        int j;
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                int temp = array[i];
                for (j = i; j >= gap && array[j - gap] > temp; j -= gap) {
                    array[j] = array[j - gap];
                }
                array[j] = temp;
            }
        }
    }

    private static void HeapSort(int[] array) {
        for (int i = array.length / 2 - 1; i >= 0; i--)
            shiftDown(array, i, array.length);
        for (int i = array.length - 1; i > 0; i--) {
            swap(array, 0, i);
            shiftDown(array, 0, i);
        }
    }

    private static void shiftDown(int[] array, int i, int n) {
        int child;
        int tmp;

        for (tmp = array[i]; leftChild(i) < n; i = child) {
            child = leftChild(i);
            if (child != n - 1 && (array[child] < array[child + 1]))
                child++;
            if (tmp < array[child])
                array[i] = array[child];
            else
                break;
        }
        array[i] = tmp;
    }

    private static int leftChild(int i) {
        return 2 * i + 1;
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    private static void MergeSort(int[] array, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            MergeSort(array, low, mid);
            MergeSort(array, mid + 1, high);
            merge(array, low, mid, high);
        }
    }

    private static void merge(int[] array, int low, int mid, int high) {

        int n = high - low + 1;
        int[] Temp = new int[n];

        int i = low, j = mid + 1;
        int k = 0;

        while (i <= mid || j <= high) {
            if (i > mid)
                Temp[k++] = array[j++];
            else if (j > high)
                Temp[k++] = array[i++];
            else if (array[i] < array[j])
                Temp[k++] = array[i++];
            else
                Temp[k++] = array[j++];
        }
        for (j = 0; j < n; j++)
            array[low + j] = Temp[j];
    }

    private static void insertionSort(int[] elements) {
        for (int i = 1; i < elements.length; i++) {
            int key = elements[i];
            int j = i - 1;
            while (j >= 0 && key < elements[j]) {
                elements[j + 1] = elements[j];
                j--;
            }
            elements[j + 1] = key;
        }
    }
}

class Input {

    private BufferedReader input;

    Input() {
        input = new BufferedReader(new InputStreamReader(System.in));
    }

    public int ReadInt() throws Exception {
        return Integer.parseInt(input.readLine());
    }

    public long ReadLong() throws Exception {
        return Long.parseLong(input.readLine());
    }

    public String ReadString() throws Exception {
        return input.readLine();
    }

    public int[] ReadArrayInt(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToInt(Integer::parseInt).toArray();
    }

    public long[] ReadArrayLong(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToLong(Long::parseLong).toArray();
    }

    public String[] ReadArrayString(String split) throws Exception {
        return input.readLine().split(split);
    }
}

class Output {
    public void WriteArray(int[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(long[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(String[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args){
        int[] val = new int[100];
        for(int i=0;i<100;i++){
            val[i] = 0;
        }
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        for(int i=0;i<n;i++){
            int x = scan.nextInt();
            val[x-1]++;
        }
        int max = 0;
        for(int i=0;i<100;i++){
            if(val[i] > max){
                max = val[i];
            }
        }
        System.out.println(max);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String firstLine = br.readLine();
        int n = Integer.parseInt(firstLine);
        String[] inputLine = br.readLine().split(" ");
        int[] input = new int[n];
        for (int i = 0; i < n; i++) {
            input[i] = Integer.parseInt(inputLine[i]);
        }
        Arrays.sort(input);
        int max = 1;
        int count = 1;
        for (int i = 0; i < n - 1; i++) {
            if (input[i] == input[i + 1]) {
                count++;
            } else {
                if (max < count) {
                    max = count;
                }
                count = 1;
            }
        }
        if (max < count) {
            max = count;
        }
        System.out.println(max);

    }
}

/*public class main {
    public static void main(String[] str){
        System.out.println(hammingDistance(4,1));
    }

    public static int hammingDistance(int x, int y) {
        int result = x^y;
        String strResult = tenToTwo(result);
        int count = 0;
        for (int i=0; i<strResult.length(); i++){
            if(strResult.charAt(i) == '1'){
                count++;
            }
        }
        return count;
    }

    public static String tenToTwo(int number){
        String result = "";
        while(number > 1) {
            result = number%2 + result;
            number = number/2;
        }
        result = number + result;
        return result;
    }
}*/

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner teclado = new Scanner(System.in);
        int T = teclado.nextInt();
        ArrayList<Integer> array = new ArrayList<Integer>();
        for (int i = 0; i < T; ++i) {
            array.add(teclado.nextInt());
        }

        Integer v[] = new Integer[array.size()];
        int i = 0;
        for (int aux : array) {
            if (i < array.size()) {
                v[i] = aux;
            }
            i++;
        }

        int file[] = new int[100];
        for (int j = 0; j < v.length; ++j) {
            Integer freq = Collections.frequency(array, v[j]);
            file[j] = freq;
        }
        Arrays.sort(file);
        System.out.println(file[file.length - 1]);
    }

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.util.Scanner;

public class PolycarpsPocket {
    public static void main(String[]args) {
        Scanner s = new Scanner(new BufferedReader(new InputStreamReader(System.in)));
        int n=s.nextInt();
        int[]array=new int[n];
        int repeated=0;
        int max=0;
        for(int i=0;i<n;i++)
            array[i]=s.nextInt();
        if(n==1)
            System.out.println(1);
        else{
        for(int i=0;i<n-1;i++){
            repeated=0;
            for(int j=i+1;j<n;j++){
                if(array[i]==array[j])
                    repeated++;
            }
            if(repeated>max)
                max=repeated;
        }

        System.out.println(max+1);
    }
    }
    }

// #pragma GCC optimize("Ofast")
// #pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")

import java.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Main {
    static int infi = Integer.MAX_VALUE / 2, mod = 1000000007, maxn = 3 * (int) 1e5;
    static long infl = Long.MAX_VALUE / 2;

    public static void main(String[] args) throws IOException {
        br = new BufferedReader(new InputStreamReader(System.in));
        out = new PrintWriter(System.out);
        int n = nextInt();
        int[] a = new int[101];
        int max = 0;
        for (int i = 0; i < n; i++) {
            int x = nextInt();
            a[x]++;
            max = max(max,a[x]);
        }
        out.print(max);
        out.close();
    }

    static BufferedReader br;
    static StringTokenizer st = new StringTokenizer("");
    static PrintWriter out;

    static String next() throws IOException {
        while (!st.hasMoreTokens()) {
            st = new StringTokenizer(br.readLine());
        }
        return st.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt(next());
    }

    static long nextLong() throws IOException {
        return Long.parseLong(next());
    }

}

class f {
    int x, y;

    public f(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.Arrays;
import java.math.BigInteger;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
     public static void main (String[] args) throws java.lang.Exception
     {
     	Scanner in =new Scanner(System.in);
		int l,n,k,r,j,t=1,i,m,p,h;
		String s="",st="";
		int x,y,z;
	     for(i=0;i<t;i++)
		{
		     n=in.nextInt();
		     int a[]=new int[n];
		     for(j=0;j<n;j++)
		          a[j]=in.nextInt();
		     Arrays.sort(a);
		     p=1;m=0;
		     for(j=0;j<n;j++)
		     {
		          if(j!=n-1 && a[j]==a[j+1])
		               p++;
		          else
		          {
		               if(p>m)
		                    m=p;
		               p=1;
		          }
		     }
		     System.out.println(m);
		}
     }
}

import java.util.Scanner;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Map;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.lang.Math;

public class Main{
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int t = sc.nextInt(), coins[] = new int[101];
		for(int i = 0; i< t; i++) {
			int x = sc.nextInt();
			coins[x] = coins[x] + 1;
		}
		int m = 0;
		for(int i = 0; i<101; i++) {
			m = Math.max(m,  coins[i]);
		}
		System.out.println(m);
		sc.close();
	}
}

import java.util.*;
public class file {

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);

		int n = s.nextInt();
		int[] array = new int[101];
		for(int i = 1 ; i<=n ; i++) {
			int temp = s.nextInt();
			array[temp]++;
		}
		Arrays.sort(array);
		System.out.println(array[100]);
	}

}

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.io.FileInputStream;
public class P1003A{
    public static int n;
    public static int [] data;
    public static void readInput() throws IOException
    {
        try(BufferedReader in = new BufferedReader(new InputStreamReader(System.in)))
        {
            data = new int [102];
            for(int i = 1; i <= 100; i++)
                data[i] = 0;
            n = Integer.parseInt(in.readLine());
            String [] a = in.readLine().split(" ");
            for(int i = 0; i < n; i++)
                data[Integer.parseInt(a[i])]++;
        }
    }
    public static void main(String [] args)
    {
        try {
            readInput();
        }catch(IOException e){
            System.err.println(e);
        }
        int maxv = 0;
        for(int i = 1; i <= 100; i++)
            maxv = Integer.max(maxv, data[i]);
        System.out.println(maxv);
    }
}

import java.io.IOException;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author kinan
 */
public class Pockets {

    public static void main(String[] args) throws IOException {

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int [] f = new int[n];

        for (int i=0;i<n;i++){
            f[i]= Integer.parseInt(scanner.next());
        }

   int count = 1, tempCount;

  int temp;
  for (int i = 0; i < n-1; i++)
  {
    temp = f[i];

    if (f[0] ==f[i] ){
    tempCount = 1;}
    else tempCount=0;
    for (int j = 1; j < n; j++)
    {
      if (temp == f[j]) {
          tempCount++;
      }
    }
    if (tempCount > count)
    {

      count = tempCount;
    }

}

     System.out.print(count);
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Scanner;
import java.util.HashMap;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        Scanner in = new Scanner(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        APolycarpsPockets solver = new APolycarpsPockets();
        solver.solve(1, in, out);
        out.close();
    }

    static class APolycarpsPockets {
        public void solve(int testNumber, Scanner in, PrintWriter out) {

            int n = in.nextInt();
            in.nextLine();
            int[] nums = new int[n];

            for (int i = 0; i < n; i++) {
                nums[i] = in.nextInt();
            }

            Map<Integer, Integer> map = new HashMap<>();
            for (int i = 1; i <= 100; i++) {
                map.put(i, 0);
            }

            for (int i = 0; i < n; i++) {
                int key = nums[i];
                int keyVal = map.get(key);
                map.put(key, keyVal + 1);
            }

            int max = Integer.MIN_VALUE;
            for (int i = 1; i <= 100; i++) {
                int keyVal = map.get(i);
                max = Math.max(max, keyVal);
            }

            out.print(max);
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Rishabhdeep Singh
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] cnt = new int[101];
            Arrays.fill(cnt, 0);
            for (int i = 0; i < n; i++) {
                cnt[in.nextInt()]++;
            }
            long sum = cnt[0];
            for (int i = 0; i < 101; i++) {
                sum = Math.max(sum, cnt[i]);
            }
            out.print(sum);
        }

    }

    static 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 close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.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 nextInt() {
            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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

public class PolycarpPockets {

	public static void main(String [] args)
	{
		Scanner reader = new Scanner(System.in);
		Map<Integer,Integer> m = new HashMap<Integer,Integer>();
		int n = reader.nextInt();

		for(int i = 0; i < n; i++)
		{
			int x = reader.nextInt();
			if(!m.containsKey(x))
				m.put(x,1);
			else
				m.put(x,m.get(x)+1);
		}

		int max = 0;
		for(int i : m.values())
			if(i > max)
				max = i;
		System.out.println(max);

	}

}

import java.util.*;
import java.lang.*;
public class Main {
    public static void main(String args[]) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		HashMap<Integer,Integer> map = new HashMap<Integer,Integer>();
		for(int i=0;i<n;i++)
		{
		    int x = sc.nextInt();
		    if(map.containsKey(x))
		        map.put(x,map.get(x)+1);
		    else
		        map.put(x,1);
		}
		int ans = -1;
		for(int i:map.keySet())
		    ans = Math.max(map.get(i),ans);
		System.out.println(ans);
    }
}

import java.io.DataInputStream;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
import java.math.BigDecimal;
import java.math.BigInteger;

public class JavaApplication9 {

//***************************************************************************************
    static class Reader
    {
        final private int BUFFER_SIZE = 1 << 16;
        private DataInputStream din;
        private byte[] buffer;
        private int bufferPointer, bytesRead;

        public Reader()
        {
            din = new DataInputStream(System.in);
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public Reader(String file_name) throws IOException
        {
            din = new DataInputStream(new FileInputStream(file_name));
            buffer = new byte[BUFFER_SIZE];
            bufferPointer = bytesRead = 0;
        }

        public String readLine() throws IOException
        {
            byte[] buf = new byte[64]; // line length
            int cnt = 0, c;
            while ((c = read()) != -1)
            {
                if (c == '\n')
                    break;
                buf[cnt++] = (byte) c;
            }
            return new String(buf, 0, cnt);
        }

        public int nextInt() throws IOException
        {
            int ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do
            {
                ret = ret * 10 + c - '0';
            }  while ((c = read()) >= '0' && c <= '9');

            if (neg)
                return -ret;
            return ret;
        }

        public long nextLong() throws IOException
        {
            long ret = 0;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();
            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');
            if (neg)
                return -ret;
            return ret;
        }

        public double nextDouble() throws IOException
        {
            double ret = 0, div = 1;
            byte c = read();
            while (c <= ' ')
                c = read();
            boolean neg = (c == '-');
            if (neg)
                c = read();

            do {
                ret = ret * 10 + c - '0';
            }
            while ((c = read()) >= '0' && c <= '9');

            if (c == '.')
            {
                while ((c = read()) >= '0' && c <= '9')
                {
                    ret += (c - '0') / (div *= 10);
                }
            }

            if (neg)
                return -ret;
            return ret;
        }

        private void fillBuffer() throws IOException
        {
            bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
            if (bytesRead == -1)
                buffer[0] = -1;
        }

        private byte read() throws IOException
        {
            if (bufferPointer == bytesRead)
                fillBuffer();
            return buffer[bufferPointer++];
        }

        public void close() throws IOException
        {
            if (din == null)
                return;
            din.close();
        }
    }
//****************************************************************************************
/*static boolean isp(long n)
{

   if(n==3||n==2)
   return true;
   if(n%2==0||n%3==0||n==1)
   return false;
   for(int i=5;i*i<=n;i=i+6)
   {
       if(n%i==0||n%(i+2)==0)
       return false;
   }
   return true;
}*/
//********************************************************
   /* static int factorial(int n)
    {
        if (n == 0)
          return 1;

        return n*factorial(n-1);
    } */
    /*  public int BinaryToDecimal(int binaryNumber){

    int decimal = 0;
    int p = 0;
    while(true){
      if(binaryNumber == 0){
        break;
      } else {
          int temp = binaryNumber%10;
          decimal += temp*Math.pow(2, p);
          binaryNumber = binaryNumber/10;
          p++;
       }
    }
    return decimal;
   }*/

/*-**********************  Start   *********************************-*/

public static void main(String[] args) throws IOException{
//-----------------------  Input   ---------------------------------------//

Reader st=new Reader();
Scanner in=new Scanner(System.in);
int t=st.nextInt(),b,s=0;
int a[]=new int [101];

for(int i=0;i<t;i++)
{
    b=st.nextInt();
    a[b]++;

   //

}
int m=-1;
for(int i=0;i<a.length;i++)
{
 if(a[i]>m)m=a[i];
}
System.out.println(m);
}}

import java.util.Collection;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.Map;
import java.util.Scanner;
import java.util.Set;

/**
 *
 * @author Eman
 */
public class Codeforces {

    public static void main(String[] args) {
        // TODO code application logic here

        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        Map<Integer, Integer> map = new LinkedHashMap<Integer, Integer>();

        for (int i = 0; i < n; i++) {
            int num = in.nextInt();
            if (map.containsKey(num)) {
                map.replace(num, map.get(num) + 1);
            } else {
                map.put(num, 1);
            }
        }

        Collection c = map.values();
        System.out.println(Collections.max(c));
        //System.out.println(map);

    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Polycarp_Pocket {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        HashMap <Integer,Integer> value=new HashMap<>();
        for(int i=0;i<number;i++){
            int input=sc.nextInt();
            if(value.containsKey(input)) {
                value.put(input, value.get(input)+1);
            } else {
                value.put(input, 1);
            }
        }

        int totalPocket = 1;

        for (Map.Entry<Integer, Integer> data: value.entrySet()) {
            if (data.getValue()>totalPocket) {
                totalPocket = data.getValue();
            }
        }

        System.out.println(totalPocket);
    }
}

import java.util.Scanner;
public class  qwe {
    public static void main(String[] args) {
        Scanner STDIN = new Scanner(System.in);
        int a = STDIN.nextInt();
        int result = 0;
        int[] array = new int[a];
        if (a == 1) {
            int d = STDIN.nextInt();
            System.out.println("1");
        } else{
            for (int k = 0; k < a; k++){
                array[k] = STDIN.nextInt();
            }
            for (int i = 0; i < a; i++){
                int num = 0;
                for (int j = i; j < a; j++){
                    if (array[i] == array[j]){
                        num += 1;
                    }
                }
                if (num > result){
                    result = num;
                }
            }
            System.out.println(result);
        }
    }
}

import java.util.Arrays;
import java.util.Scanner;
public class Solution4 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		Solution4 tr = new Solution4();
		tr.test(sc);
		sc.close();
	}
	void test(Scanner sc){
		int N = sc.nextInt();
		int[] in = new int[N];
		if(N==1){
			System.out.println(1);
			return;
		}

		for (int i = 0; i < in.length; i++) {
			in[i]=sc.nextInt();
		}

		Arrays.sort(in);
		int max=1;
		int same=1;

		for (int i = 1; i < in.length; i++) {
			if(in[i]==in[i-1]){
				same++;
			}else{
				same=1;
			}
			if(same > max){
				max=same;
			}
		}
		System.out.println(max);
/*		if(N==2){
			if(in[0]!=in[1]){
				System.out.println(2);
				return;
			}
			System.out.println(1);
			return;
		}*/

	}
}

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int size=sc.nextInt();
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<size;i++){
            int temp=sc.nextInt();
            if(map.containsKey(temp)){
                map.put(temp,map.get(temp)+1);
            }
            else map.put(temp,1);
        }
        int min=0;
        for(Map.Entry mapElement: map.entrySet()){
            if((int)mapElement.getValue()>min)min=(int)mapElement.getValue();
        }
        System.out.println(min);
    }
}

import java.io.BufferedReader;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Vector;
import java.util.Comparator;
import java.util.BitSet;
import java.util.Collections;
import java.util.Scanner;
import java.io.PrintWriter;

public class naive {

	public static void main(String[] args) throws IOException {
		Scanner Readerbinary = new Scanner(System.in);
		PrintWriter out = new PrintWriter(System.out);
		int n= Readerbinary.nextInt();
		int k=1;
		int[] str= new int[n];
		for(int i=0; i<n; i++)
			str[i]=Readerbinary.nextInt();
		Arrays.sort(str);
		int ans=k;
		for(int i=1; i<n ;i++)
		{
			int m=1;
			for(int j=i; j<n;j++)
			{
				if(str[j]!=str[j-1])
					break;
				else
				{
					if(str[j]==str[j-1])
						m++;
				}

			}
			ans=Integer.max(ans, m);
		}

		System.out.println(ans);
		out.flush();

		}
	static class Scanner

	{
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s){	br = new BufferedReader(new InputStreamReader(s));}

		public String next() throws IOException
		{
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine());
			return st.nextToken();
		}

		public int nextInt() throws IOException {return Integer.parseInt(next());}

		public long nextLong() throws IOException {return Long.parseLong(next());}

		public String nextLine() throws IOException {return br.readLine();}

		public double nextDouble() throws IOException
		{
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if(x.charAt(0) == '-')
			{
				neg = true;
				start++;
			}
			for(int i = start; i < x.length(); i++)
				if(x.charAt(i) == '.')
				{
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				}
				else
				{
					sb.append(x.charAt(i));
					if(dec)
						f *= 10;
				}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg?-1:1);
		}

		public boolean ready() throws IOException {return br.ready();}

	}

}

import java.util.*;
	public class Main{
	public static void main(String[]args){
			TreeMap<Integer,Integer> map=new TreeMap<>();
			Scanner sc=new Scanner(System.in);
			int n;
			n=sc.nextInt();
			for(int i=0;i<n;i++){
				int a;
				a=sc.nextInt();{
				if(!map.containsKey(a))map.put(a,0);
				if(map.containsKey(a))map.put(a,map.get(a)+1);
					}
				}
				int max=0;
				for(Map.Entry<Integer, Integer> i : map.entrySet()){
            max = Math.max(max, i.getValue());
        }
					System.out.print(max);
		}
	}

//package JCFULY3;

import java.io.*;
import java.util.*;

public class Q1{

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public char nextChar() {
            return next().charAt(0);
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public int[] nextIntArr(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextInt();
            }
            return arr;
        }

        public Integer[] nextIntegerArr(int n) {
            Integer[] arr = new Integer[n];
            for (int i = 0; i < n; i++) {
                arr[i] = new Integer(this.nextInt());
            }
            return arr;
        }

        public int[][] next2DIntArr(int n, int m) {
            int[][] arr = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    arr[i][j] = this.nextInt();
                }
            }
            return arr;
        }

        public int[] nextSortedIntArr(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextInt();
            }
            Arrays.sort(arr);
            return arr;
        }

        public long[] nextLongArr(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextLong();
            }
            return arr;
        }

        public char[] nextCharArr(int n) {
            char[] arr = new char[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextChar();
            }
            return arr;
        }
    }

    public static void main(String[] args) {

        InputReader in = new InputReader();
        int N = in.nextInt();

        int input[]=new int[N];
        // int k=in.nextInt();
        HashMap<Integer,Integer> map1=new HashMap<>();

        int flag=-1;

//        if(N==0){
//            System.out.println(0);
//            return;
//        }

        for (int i = 0; i < N; i++) {

            input[i]=in.nextInt();
            if(map1.containsKey(input[i])){
                map1.put(input[i],map1.get(input[i])+1);
            }else{
                map1.put(input[i],1);
            }

        }

int max=1;

        for(Map.Entry<Integer,Integer> data: map1.entrySet()){

            if(data.getValue()>max)
                max=data.getValue();

        }

        System.out.println(max);
//        if(flag==1) {
//            System.out.println(2);
//            return;
//        }
//
//        System.out.println(1);

    }

    static int upperBound(long[] list, long val) {
        int count = list.length - 1, first = 0, it = 0, step = 0;

        while (count > 0) {
            it = first;
            step = count / 2;
            it += step;
            if (!(val < list[it])) {
                first = it + 1;
                it++;
                count -= step + 1;
            } else {
                count = step;
            }
        }
        return first;
    }

}

import java.util.Scanner;

public class CF1003A {
    public static void main(String args[]) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int ans = 0;
        int a[] = new int[106];
        for (int i=0;102>=i;i++) a[i] = 0;
        for (int i=1;n>=i;i++) {
            int x = scanner.nextInt();
            a[x]++;
            if (a[x] > ans) ans = a[x];
            //ans = max(ans,a[x]);
        }
        System.out.println(ans);
    }
}

import java.util.*;
public class Main {
	public static void main(String[] args){
		Scanner sc=new Scanner(System.in);
		int n=sc.nextInt();
		int[] x=new int[n];
		for(int i=0;i<n;i++){
			x[i]=sc.nextInt();
		}
		Arrays.sort(x);
		int sum=1,max=1;
		for(int i=0;i<n-1;i++){
			while(x[i]==x[i+1]){
				sum++;
				i++;
				if(i==n-1)
					break;
			}
			if(sum>max)
				max=sum;
			sum=1;
		}
		System.out.println(max);
	}
}

import java.util.ArrayList;
import java.util.HashSet;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

//        Contest494_A q = new Contest494_A();
//        q.qwerty();
        Scanner in = new Scanner (System.in);
        int n = in.nextInt();
        in.nextLine();
        String s = in.nextLine();
        String[] ss = s.split(" ");
        ArrayList<Integer> arr = new ArrayList<Integer>();
        HashSet<Integer> coinsSet = new HashSet<Integer>();
        for(int i = 0; i < n; i++){
            arr.add(Integer.valueOf(ss[i]));
        }

        int i = 0;
        int count = 0;
        while (n > 0){
//            System.out.println(arr);
//            System.out.println(coinsSet);
//            System.out.println(i);
//            System.out.println();
            if (!coinsSet.contains(arr.get(i))){
                coinsSet.add(arr.get(i));
                arr.remove(i);
                n--;
                if (i >= n){
                    i = 0;
                    count++;
                    coinsSet.clear();
//                    System.out.println("Set cleared from inside");
//                    System.out.println();
                }
            }
            else {
                if (i < n - 1) {
                    i++;
                } else {
                    i = 0;
                    count++;
                    coinsSet.clear();
//                    System.out.println("Set cleared!");
//                    System.out.println();
                }
            }
        }
        System.out.println(count);
    }
}

import java.util.Scanner;

import static java.lang.Integer.parseInt;
import static java.lang.Math.max;

public class Main {
    static int n,f[];
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        in.nextLine();
        f = new int[101];
        for (int i = 0; i < n; i++) {
            f[in.nextInt()]++;
        }
        int ans = 0;
        for (int i = 1; i <= 100; i++) {
            ans = max(f[i],ans);
        }
        System.out.println(ans);

    }
}

import java.util.*;
import java.io.*;
public class pocket {
    public static void main(String args[]) throws IOException {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int a[] = new int[n];
       int freq[]=new int[101];
        int max=-1;
       for(int i=0;i<n;i++)
       {
           a[i]=sc.nextInt();
           freq[a[i]]++;
           if(freq[a[i]]>max)
           {
               max=freq[a[i]];
           }
       }
       System.out.println(max);
    }
}

import java.io.*;
import java.lang.*;
import java.util.*;

public class Main {

    public static void main(String[] args) throws Exception {
        Input input = new Input();
        Output output = new Output();
        int quantity = input.ReadInt();
        Thread.sleep(1500);
        int [] base = FastSort.SortWithReturn(input.ReadArrayInt(" " ), 3, quantity);
        int pred = base[0];
        int count = 1;
        int answer = 1;
        for (int index = 1 ; index < quantity; index++){
            if (base[index] == pred){
                count++;
            }else{
                if (answer < count){
                    answer = count;
                }
                count = 1;
            }
            pred = base[index];
        }
        System.out.println(count > answer ? count : answer);
    }
}

class method {

    public static int gcd(int a, int b) { // NOD
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static long gcd(long a, long b) {
        if (b == 0) {
            return a;
        }
        return gcd(b, a % b);
    }

    public static int lcm(int a, int b) { // NOK
        return a / gcd(a, b) * b;
    }

    public static long lcm(long a, long b) {
        return a / gcd(a, b) * b;
    }
}

class FastSort {

    public static void SortWithoutReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
    }

    public static int[] SortWithReturn(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        sort(array, ShellHeapMergeMyInsertionSort, length);
        return array;
    }

    private static void sort(int[] array, int ShellHeapMergeMyInsertionSort, int length) {
        Random random = new Random();
        if (ShellHeapMergeMyInsertionSort < 0 || ShellHeapMergeMyInsertionSort > 4) {
            ShellHeapMergeMyInsertionSort = random.nextInt(4);
        }
        if (ShellHeapMergeMyInsertionSort == 0) {
            ShellSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 1) {
            HeapSort(array);
        } else if (ShellHeapMergeMyInsertionSort == 2) {
            MergeSort(array, 0, length - 1);
        } else if (ShellHeapMergeMyInsertionSort == 3) {
            StraightMergerSort(array, length);
        } else if (ShellHeapMergeMyInsertionSort == 4) {
            insertionSort(array);
        }
    }

    private static void StraightMergerSort(int[] array, int size) {
        if (size == 0) {
            return;
        }
        int length = (size / 2) + ((size % 2) == 0 ? 0 : 1);
        Integer[][] ZeroBuffer = new Integer[length + length % 2][2];
        Integer[][] FirstBuffer = new Integer[0][0];
        for (int index = 0; index < length; index++) {
            int ArrayIndex = index * 2;
            int NextArrayIndex = index * 2 + 1;
            if (NextArrayIndex < size) {
                if (array[ArrayIndex] > array[NextArrayIndex]) {
                    ZeroBuffer[index][0] = array[NextArrayIndex];
                    ZeroBuffer[index][1] = array[ArrayIndex];
                } else {
                    ZeroBuffer[index][0] = array[ArrayIndex];
                    ZeroBuffer[index][1] = array[NextArrayIndex];
                }
            } else {
                ZeroBuffer[index][0] = array[ArrayIndex];
            }
        }
        boolean position = false;
        int pointer0;
        int pointer;
        int pointer1;
        int number = 4;
        int NewPointer;
        int count;
        Integer[][] NewBuffer;
        Integer[][] OldBuffer;
        length = (size / 4) + ((size % 4) == 0 ? 0 : 1);
        while (true) {
            pointer0 = 0;
            count = (number / 2) - 1;
            if (!position) {
                FirstBuffer = new Integer[length + length % 2][number];
                NewBuffer = FirstBuffer;
                OldBuffer = ZeroBuffer;
            } else {
                ZeroBuffer = new Integer[length + length % 2][number];
                NewBuffer = ZeroBuffer;
                OldBuffer = FirstBuffer;
            }
            for (int i = 0; i < length; i++) {
                pointer = 0;
                pointer1 = 0;
                NewPointer = pointer0 + 1;
                if (length == 1) {
                    for (int g = 0; g < size; g++) {
                        if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                            if (OldBuffer[pointer0][pointer] == null) {
                                continue;
                            }
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                            array[g] = OldBuffer[NewPointer][pointer1];
                            pointer1++;
                        } else {
                            array[g] = OldBuffer[pointer0][pointer];
                            pointer++;
                        }
                    }
                    return;
                }
                for (int g = 0; g < number; g++) {
                    if (pointer > count || OldBuffer[pointer0][pointer] == null) {
                        if (OldBuffer[NewPointer][pointer1] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else if (pointer1 > count || OldBuffer[NewPointer][pointer1] == null) {
                        if (OldBuffer[pointer0][pointer] == null) {
                            continue;
                        }
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    } else if (OldBuffer[pointer0][pointer] >= OldBuffer[NewPointer][pointer1]) {
                        NewBuffer[i][g] = OldBuffer[NewPointer][pointer1];
                        pointer1++;
                    } else {
                        NewBuffer[i][g] = OldBuffer[pointer0][pointer];
                        pointer++;
                    }
                }
                pointer0 += 2;
            }
            position = !position;
            length = length / 2 + (length % 2 == 0 ? 0 : 1);
            number *= 2;

        }
    }

    public static void ShellSort(int[] array) {
        int j;
        for (int gap = array.length / 2; gap > 0; gap /= 2) {
            for (int i = gap; i < array.length; i++) {
                int temp = array[i];
                for (j = i; j >= gap && array[j - gap] > temp; j -= gap) {
                    array[j] = array[j - gap];
                }
                array[j] = temp;
            }
        }
    }

    private static void HeapSort(int[] array) {
        for (int i = array.length / 2 - 1; i >= 0; i--)
            shiftDown(array, i, array.length);
        for (int i = array.length - 1; i > 0; i--) {
            swap(array, 0, i);
            shiftDown(array, 0, i);
        }
    }

    private static void shiftDown(int[] array, int i, int n) {
        int child;
        int tmp;
        for (tmp = array[i]; leftChild(i) < n; i = child) {
            child = leftChild(i);
            if (child != n - 1 && (array[child] < array[child + 1]))
                child++;
            if (tmp < array[child])
                array[i] = array[child];
            else
                break;
        }
        array[i] = tmp;
    }

    private static int leftChild(int i) {
        return 2 * i + 1;
    }

    private static void swap(int[] array, int i, int j) {
        int temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }

    private static void MergeSort(int[] array, int low, int high) {
        if (low < high) {
            int mid = (low + high) / 2;
            MergeSort(array, low, mid);
            MergeSort(array, mid + 1, high);
            merge(array, low, mid, high);
        }
    }

    private static void merge(int[] array, int low, int mid, int high) {
        int n = high - low + 1;
        int[] Temp = new int[n];
        int i = low, j = mid + 1;
        int k = 0;
        while (i <= mid || j <= high) {
            if (i > mid)
                Temp[k++] = array[j++];
            else if (j > high)
                Temp[k++] = array[i++];
            else if (array[i] < array[j])
                Temp[k++] = array[i++];
            else
                Temp[k++] = array[j++];
        }
        for (j = 0; j < n; j++)
            array[low + j] = Temp[j];
    }

    private static void insertionSort(int[] elements) {
        for (int i = 1; i < elements.length; i++) {
            int key = elements[i];
            int j = i - 1;
            while (j >= 0 && key < elements[j]) {
                elements[j + 1] = elements[j];
                j--;
            }
            elements[j + 1] = key;
        }
    }
}

class Input {

    private BufferedReader input;

    Input() {
        input = new BufferedReader(new InputStreamReader(System.in));
    }

    public int ReadInt() throws Exception {
        return Integer.parseInt(input.readLine());
    }

    public long ReadLong() throws Exception {
        return Long.parseLong(input.readLine());
    }

    public String ReadString() throws Exception {
        return input.readLine();
    }

    public int[] ReadArrayInt(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToInt(Integer::parseInt).toArray();
    }

    public long[] ReadArrayLong(String split) throws Exception {
        return Arrays.stream(input.readLine().split(split)).mapToLong(Long::parseLong).toArray();
    }

    public String[] ReadArrayString(String split) throws Exception {
        return input.readLine().split(split);
    }
}

class Output {
    public void WriteArray(int[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(long[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }

    public void WriteArray(String[] array, String split) {
        StringBuilder answer = new StringBuilder();
        for (int index = 0; index < array.length; index++) {
            answer.append(array[index]);
            if (index + 1 < array.length) {
                answer.append(split);
            }
        }
        System.out.println(answer);
    }
}

import java.util.*;
public class Main{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
       int n =scan.nextInt();
       int[] A = new int[n];
       for(int i=0;i<n;i++) A[i]=scan.nextInt();

       int[] freq = new int[102];
       Arrays.fill(freq,0);
       for(int i=0;i<n;i++) freq[A[i]]++;
       int ans=0;
       for(int i=0;i<=100;i++){
           ans = Math.max(ans, freq[i]);
       }
       System.out.println(ans);
    }
}

import java.util.Scanner;
public class Main{
    public static void main(String[] args) {
        Scanner in=new Scanner(System.in);
        int a=in.nextInt();
        int n[]=new int[a];
        for (int i = 0; i < a; i++) {
            n[i]=in.nextInt();
        }
        int max=0;
        int count=0;
        for (int i = 0; i < a; i++) {
            count=0;
            for (int j = 0; j < a; j++) {
                if(n[i]==n[j]){
                    count++;
                }
            }
            if(count>max){
                max=count;
            }
        }
        System.out.println(max);
    }
}

import java.util.Scanner;
import java.util.Arrays;
import java.util.*;
public class pocket
{
    public static void main(String args[])
    {
        Scanner s=new Scanner(System.in);
        int n,c=0,i,j,k=0;
        n=s.nextInt();
        int a[]=new int[n];
        for(i=0;i<n;i++)
        a[i]=s.nextInt();
        for(i=0;i<n;i++)
        {   k=1;
            for(j=i+1;j<n;j++)
            {
            if(a[i]==a[j])
            k++;
            }
            if(k>c)
            {
            c=k;
            k=1;
        }
            }

            System.out.println(c);
        }
    }

import java.util.Arrays;
import java.util.Scanner;

public class _141PolycarpsPockets {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);
		int n=sc.nextInt();
		int[] arr = new int[n];

		for(int i=0;i<n;i++) {
			arr[i]=sc.nextInt();
		}

		Arrays.sort(arr);
		int count=1;
		int max=1;
		for(int i=0;i<n-1;i++) {
			if(arr[i]==arr[i+1]) {
				count++;
			}
			else {
				count=1;
			}
			max=Math.max(count, max);
		}
		System.out.println(max);
	}

}

//Codeforces 1003A
import java.util.Scanner;
import java.util.HashMap;

public class CF1003A {
    static final Scanner SC = new Scanner(System.in);
    public static void main(String[] args) {
        HashMap<Integer, Integer> coinCount = new HashMap<>();
        int coins = SC.nextInt();
        int maxOccurrences = 1;
        for (int c = 0; c < coins; ++c) {
            int coinValue = SC.nextInt();
            if (coinCount.containsKey(coinValue)) {
                int count = coinCount.get(coinValue) + 1;
                coinCount.put(coinValue, count);
                maxOccurrences = Math.max(maxOccurrences, count);
            }
            else
                coinCount.put(coinValue, 1);
        }
        System.out.println(maxOccurrences);
    }
}

import java.util.Scanner;

public class Main {
	static int arr[] = new int[101];
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int N = sc.nextInt();
		for(int i = 0 ; i < N ; i++) {
			arr[sc.nextInt()]++;
		}
		int res = 0;
		for(int i = 1; i<101 ; i++) {
			res = Math.max(res, arr[i]);
		}
		System.out.println(res);
	}

}

import java.util.Arrays;
import java.util.Scanner;

/**
 *
 * @author PD
 */
public class Codeforcesbonus1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        int[] data = new int[101];
        for (int i = 0; i < n; i++) {
            int temp = input.nextInt();
            data[temp]++;
        }
        Arrays.sort(data);
        System.out.println(data[100]);
    }

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        A a = new A(in, out);
        a.run();
        out.close();
    }

    public static class A{

        InputReader in ;
        PrintWriter out;

        public A(InputReader in, PrintWriter out) {
            this.in = in;
            this.out = out;
        }

        public void run(){
            int n = in.nextInt();
            List<Integer> coins = new ArrayList<>(101);
            IntStream.range(0,101).forEach( e-> coins.add(0));
            IntStream.range(0,n).forEach( e-> {
                int num = in.nextInt();
                coins.set(num,coins.get(num)+1);
            });

            int answer =coins.stream().mapToInt(Integer::intValue).max().getAsInt();
            out.println(answer);
//            System.out.println(answer);
//            out.println(coins);
        }
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.util.*;
import java.io.*;
public class Lo
{
    public static void main(String[] args)
    {
        Scanner s  = new Scanner(System.in);
        int n = s.nextInt();
        int[] a = new int[101];
        for(int i=0;i<n;i++)
        {
            a[s.nextInt()]++;
        }
       Arrays.sort(a);
       System.out.println(a[100]);
    }
}

import java.io.*;
public class PolyCarpPocket {

	public static void main(String[] args)throws Exception {
		// TODO Auto-generated method stub
		//Use counting sort
		int total[]=new int[100];
		int pocket=0;
		BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
		int n=Integer.parseInt(br.readLine());
		String str[]=br.readLine().split(" ");
		for(int i=0;i<n;i++)
		{
			int tmp=Integer.parseInt(str[i])-1;
			total[tmp]++;
			if(total[tmp]>pocket)
			{
				pocket=total[tmp];
			}
		}
		System.out.println(pocket);

	}

}

import java.util.Scanner;

public class Polycarps_Pockets {
    public static void main(String args[]) {
        Scanner reader = new Scanner(System.in);

        short n = reader.nextShort();
        //short[] a = new short[n];
        short[] b = new short[101];

        short max = 0;
        for (int i = 0; i < n; i++) {
            short x = reader.nextShort();
            b[x]++;
            if (b[x] > max)
                max = b[x];
        }

        reader.close();

        System.out.print(max);
    }
}

import javafx.util.Pair;

import java.io.*;
import java.util.*;

public class Main1 implements Runnable {

    long m = (int)1e9+7;
    PrintWriter w;
    ArrayList<Integer> prime;
    boolean is_prime[];
    InputReader c;
    public void run() {
        c = new InputReader(System.in);
        w = new PrintWriter(System.out);

        int n = c.nextInt();
        int[] a = scanArrayI(n);
        HashMap<Integer,Integer> hashMap = new HashMap<>();
        for(int i = 0; i < n; i++){
            if(!hashMap.containsKey(a[i])){
                hashMap.put(a[i], 1);
            } else {
                hashMap.put(a[i], hashMap.get(a[i]) + 1);
            }
        }
        int max = Integer.MIN_VALUE;
        for(int m : hashMap.values()){
            max = Math.max(max, m);
        }
        w.println(max);
        w.close();
    }

     private static int maxIndex(List<Integer> list) {
        Integer i=0, maxIndex=-1, max=null;
        for (Integer x : list) {
            if ((x!=null) && ((max==null) || (x>max))) {
                max = x;
                maxIndex = i;
            }
            i++;
        }
        return maxIndex;
    }
    private String removeSpaces(int[] a){
        StringBuilder s = new StringBuilder();
        for(int i = 0; i < 26; i++){
            s.append(a[i]);
        }
        return s.toString();
    }

    static int largest(int[] arr) {
        int i;
        int max = arr[0];
        for (i = 1; i < arr.length; i++)
            if (arr[i] > max)
                max = arr[i];
        return max;
    }

    static long gcd(long a, long b) {
        if (b == 0)
            return a;
        return gcd(b, a % b);
    }
    void sieve(int n) {
        is_prime = new boolean[n+10];
        prime = new ArrayList<>();
        for(int i=2;i<=n;i++)
            is_prime[i] = true;

        for (int i = 2; i <= n; ++i) {
            if (is_prime[i]) prime.add(i);
            for (int j = 0; j < prime.size () && i * prime.get(j) < n; ++j) {
                is_prime[i * prime.get(j)] = false;
                if (i % prime.get(j) == 0) break;
            }
        }
    }
    public static void sortbyColumn(int arr[][], int col){
        Arrays.sort(arr, new Comparator<int[]>()
        {
            public int compare(int[] o1, int[] o2){
                return(Integer.valueOf(o1[col]).compareTo(o2[col]));
            }
        });

    }
    public static class DJSet {
        public int[] upper;

        public DJSet(int n) {
            upper = new int[n];
            Arrays.fill(upper, -1);
        }

        public int root(int x) {
            return upper[x] < 0 ? x : (upper[x] = root(upper[x]));
        }

        public boolean equiv(int x, int y) {
            return root(x) == root(y);
        }

        public boolean union(int x, int y) {
            x = root(x);
            y = root(y);
            if (x != y) {
                if (upper[y] < upper[x]) {
                    int d = x;
                    x = y;
                    y = d;
                }
                upper[x] += upper[y];
                upper[y] = x;
            }
            return x == y;
        }
    }
    public static int[] radixSort(int[] f)    {
        int[] to = new int[f.length];
        {
            int[] b = new int[65537];
            for(int i = 0;i < f.length;i++)b[1+(f[i]&0xffff)]++;
            for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
            for(int i = 0;i < f.length;i++)to[b[f[i]&0xffff]++] = f[i];
            int[] d = f; f = to;to = d;
        }
        {
            int[] b = new int[65537];
            for(int i = 0;i < f.length;i++)b[1+(f[i]>>>16)]++;
            for(int i = 1;i <= 65536;i++)b[i]+=b[i-1];
            for(int i = 0;i < f.length;i++)to[b[f[i]>>>16]++] = f[i];
            int[] d = f; f = to;to = d;
        }
        return f;
    }
    public void printArray(int[] a){
        for(int i=0;i<a.length;i++)
            w.print(a[i]+" ");
        w.println();
    }
    public int[] scanArrayI(int n){
        int a[] = new int[n];
        for(int i=0;i<n;i++)
            a[i] = c.nextInt();
        return a;
    }
    public long[] scanArrayL(int n){
        long a[] = new long[n];
        for(int i=0;i<n;i++)
            a[i] = c.nextLong();
        return a;
    }
    public void printArray(long[] a){
        for(int i=0;i<a.length;i++)
            w.print(a[i]+" ");
        w.println();
    }
    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private SpaceCharFilter filter;
        private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

        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 String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            }
            catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
        public int nextInt() {
            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 long nextLong() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            long 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 double nextDouble() {
            int c = read();
            while (isSpaceChar(c))
                c = read();
            int sgn = 1;
            if (c == '-') {
                sgn = -1;
                c = read();
            }
            double res = 0;
            while (!isSpaceChar(c) && c != '.') {
                if (c == 'e' || c == 'E')
                    return res * Math.pow(10, nextInt());
                if (c < '0' || c > '9')
                    throw new InputMismatchException();
                res *= 10;
                res += c - '0';
                c = read();
            }
            if (c == '.') {
                c = read();
                double m = 1;
                while (!isSpaceChar(c)) {
                    if (c == 'e' || c == 'E')
                        return res * Math.pow(10, nextInt());
                    if (c < '0' || c > '9')
                        throw new InputMismatchException();
                    m /= 10;
                    res += (c - '0') * m;
                    c = read();
                }
            }
            return res * sgn;
        }

        public String readString() {
            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 readString();
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);
        }
    }
    public static void main(String args[]) throws Exception {
        new Thread(null, new Main1(),"Main",1<<26).start();
    }
}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
 public class Solution
{
       private static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
					private static int pocket(int arr[], int N){

               HashMap<Integer,Integer> map = new HashMap<>();
							for(int i =0;i<N;i++){
							int key = arr[i];
							if(!map.containsKey(key))
									map.put(key,1);
							else
									map.put(key,(map.get(key)+1));
}
                  int max =0;
			     for(Map.Entry<Integer,Integer> m : map.entrySet()){
    				if(m.getValue()>max)
						max = m.getValue();

}

                    return max;

}

	public static void main (String[] args) throws java.lang.Exception
	{
		// your code goes here
					int N = Integer.parseInt(br.readLine());
					String str[] = br.readLine().split(" ");
					int arr[] = new int[N];
					for(int i =0; i<N;i++){
						arr[i] = Integer.parseInt(str[i]);

}

						int count = pocket(arr,N);
							System.out.println(count);
	}
}

/*	Basic import definitions	*/
	import java.util.*;

/*	Basic Class definitions*/
	public class A1003
	{
		public static void main(String[] args)
		{
			Scanner sc = new Scanner(System.in);

			int i , j , k;
			int T,N;

			T = sc.nextInt();
                        int max = 0;
                        int a[] = new int[101];
                        for(i=0;i<T;i++)
                            a[i]=-1;

			for ( i = 0 ; i < T ; i++ )
			{
                            k = sc.nextInt();
                            if(a[k]==-1)
                                a[k]=0;
                            a[k]++;
			}
                        Arrays.sort(a);
                        System.out.println(a[100]);
		}
	}

import java.util.*;
public class work {
    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        int numOfCoins = scan.nextInt();
        int [] Values = new int[numOfCoins];
        for(int i = 0; i<numOfCoins; i++) {
            Values[i] = scan.nextInt();
            }
            int count = 0;
        for(int i = 0; i<Values.length; i++){
            int value = Values[i];
            int temporaryCount = 0;
            for(int g =0; g<Values.length; g++ ){
                int value2 = Values[g];
                if(value==value2){
                    temporaryCount ++;
                }
            }
            if(temporaryCount>count){
                count = temporaryCount;
            }
        }
        System.out.print(count);
    }
}

import java.util.HashMap;
import java.util.HashSet;
import java.util.Scanner;

public class Codeforces1003A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        HashMap<Integer,Integer> a = new HashMap<>();
        int kol = 1;
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            if (a.containsKey(x)) {
               a.put(x,a.get(x)+1);
               if(a.get(x)>kol){
                   kol = a.get(x);
               }
            } else {
                a.put(x,1);
            }
        }
            System.out.println(kol);
        in.close();
    }
}

import java.util.*;
public class file{
    private static Scanner scan;
    public static void main(String args[]){
        scan=new Scanner(System.in);
        int n;
        n=scan.nextInt();
        int i;
        int arr[]=new int[n];
        for(i=0;i<n;i++)
        arr[i]=scan.nextInt();

        int frequency[]=new int[101];
        for(i=0;i<n;i++)
          frequency[arr[i]]++;

          int max=frequency[arr[0]];
          for(i=1;i<n;i++)
          if(frequency[arr[i]]>max)
          max=frequency[arr[i]];

          System.out.println(max);

    }
}

import java.util.*;
import java.io.*;

public class polycarp_pockets {
	public static void main(String[] args) throws NumberFormatException, IOException {
		BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
		int n=Integer.parseInt(br.readLine());
		String arr=br.readLine();
		String[] arr2=arr.split(" ");
		int[] array=new int[n];
		for(int i=0;n>i;i++) {
			array[i]=Integer.parseInt(arr2[i]);
		}
		int[] pockets=new int[n];
		int max=-1;
		for(int i=0;n>i;i++) {
			int count=numOccur(array[i], array);
			if(count>max)
				max=count;
		}
		System.out.println(max);

	}
	public static int numOccur(int num,int[] arr) {
		int c=0;
		for(int i=0;arr.length>i;i++) {
			if(arr[i]==num)
				c++;
		}
		return c;

	}

}

import java.util.HashMap;
import java.util.Scanner;

public class PolycarpPocket_1003A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        int max = 1;
        for(int i=0; i<n; i++){
            int ele = s.nextInt();
            if(map.containsKey(ele)){
                int temp = map.get(ele);
                map.put(ele, temp+1);
                if(temp+1 > max){
                    max = temp+1;
                }
            }
            else{
                map.put(ele, 1);
            }
        }
        System.out.println(max);
    }
}

import javax.management.QueryEval;
import java.io.*;
import java.util.*;
public class Main {
    static List<Integer>[] al;
    static boolean[] visited;
    static int depth[];
    private static void bfs(int x){
        Queue<Integer>  q = new LinkedList<>();
        q.add(x);
        while(q.size() >  0){
            int cur = q.poll();
            visited[cur]  = true;
            for(int xx : al[cur]){
                if(!visited[xx]) {
                    q.add(xx);
                    depth[xx] = 1 + depth[cur];
                }
            }
        }
    }

   private static void solver(InputReader sc, PrintWriter out) {
        int n = sc.nextInt();
        int arr[] = new int[101];
        for(int i=0; i<n; i++) {
            int x = sc.nextInt();
            arr[x]++;
        }
        int max=0;
        for(int i=0; i<=100; i++){
            if(arr[i] > max) max = arr[i];
        }
        out.println(max);
    }
    public static void main(String[] args) throws Exception {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        solver(in,out);
        out.close();
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }
        public long nextLong() {
            return Long.parseLong(next());
        }
        public double nextDouble(){
            return Double.parseDouble(next());
        }
        public int[] readIntArray(int n){
            int arr[] = new int[n];
            for(int i=0;i<n;i++) arr[i] = nextInt();
            return arr;
        }
    }
}
class Pair implements  Comparable<Pair>{
    int x,y;
    Pair(int x, int y){
        this.x = x; this.y = y;
    }
    public int compareTo(Pair p){
        return this.x - p.x;
    }

}

import java.util.Scanner;

public class polycarp{
	public static void main(String[] args)
	{
		Scanner input = new Scanner(System.in);

		int n = input.nextInt();

		int[] count = new int[101];
		for(int i = 0; i < n; i++)
		{
			int a = input.nextInt();
			count[a]++;
		}

		int max = 0;
		for(int i = 1; i <= 100; i++)
		{
			if(max < count[i])
				max = count[i];
		}

		System.out.println(max);
	}
}

import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int max=0;
        int[] chet= new int[100];
        for (int i=0; i<100;i++){ chet[i]=0;}
        for (int i=0; i<n; i++){int a= in.nextInt(); chet [a-1]++;}
        for (int i=0;i<100;i++) {
            if (chet[i] > max) {
                max = chet[i];
            }
        }
        System.out.println(max);

    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Polycarp_Pocket {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int number = sc.nextInt();
        HashMap <Integer,Integer> value=new HashMap<>();
        for(int i=0;i<number;i++){
            int input=sc.nextInt();
            if(value.containsKey(input)) {
                value.put(input, value.get(input)+1);
            } else {
                value.put(input, 1);
            }
        }

        int totalPocket = 1;

        for (Map.Entry<Integer, Integer> data: value.entrySet()) {
            if (data.getValue()>totalPocket) {
                totalPocket = data.getValue();
            }
        }

        System.out.println(totalPocket);
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Polycarps_Pockets {

	public static void main(String[] args) {
		Scanner t = new Scanner(System.in);

		int n = t.nextInt();
		int[] a = new int[n];
		int cur = 1, max = 1;

		for (int i = 0; i < n; i++)
			a[i] = t.nextInt();

		Arrays.sort(a);

		for (int i = 0; i < n - 1; i++) {
			if (a[i] == a[i + 1])
				cur++;
			else {
				if (max < cur)
					max = cur;
				cur = 1;
			}
		}

		if (a.length != 1 && a[n - 2] == a[n - 1]) {
			if (max < cur)
				max = cur;
		}

		System.out.println(max);
	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.*;

public class A1003 {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        int n = in.nextInt();
        int pockets = 1;
        Map<Integer, Integer> coins = new HashMap();
        for (int i = 0; i < n; i++) {
            int coin = in.nextInt();
            if (coins.containsKey(coin)) {
                if (coins.get(coin) + 1 > pockets)
                    pockets = coins.get(coin) + 1;
                coins.put(coin, coins.get(coin) + 1);
            } else coins.put(coin, 1);
        }
        System.out.println(pockets);
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public String readLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public char nextChar() {
        return next().charAt(0);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(
                new InputStreamReader(System.in));

        String s;
        s = br.readLine();
        StringTokenizer st = new StringTokenizer(s);

        int coins = Integer.parseInt(st.nextToken());

        int[] arr = new int[101];
        int max = 0;

        st = new StringTokenizer(br.readLine());

        for (int i = 0; i < coins; i++) {
            int current = Integer.parseInt(st.nextToken());
            arr[current] += 1;
            max = Math.max(arr[current], max);
        }

        System.out.println(max);
    }
}

//package codeforce.problemsets;

import java.lang.reflect.Array;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

public class PolycarpPockets {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numberOfCoins = Integer.parseInt(scanner.nextLine());
        /*1 Using array but wasnt able to achive counting */
        //String [] valuesOfCoins = scanner.nextLine().split(" ");
        //Group string array ["1", "2", "2", "3"] convert to {"1": {"1"}, "2": {"2", "2"}, "3":"3"}
        //Map<Object, List<String>> uniqueCoins = Arrays.stream(valuesOfCoins).collect(Collectors.groupingBy(i -> i));

        /*2 Using list which will be grouped by collector*/
        List<String> valuesOfCoins = Arrays.asList(scanner.nextLine().split(" "));
        //This quiz requires to return highest count of the elements eg group 2 has two elements
        Map<String, Long> uniqueCoins = valuesOfCoins.stream().collect(Collectors.groupingBy(Function.identity(), Collectors.counting()));

        LinkedHashMap<String,Long> sortedReversed = new LinkedHashMap<>() ;

                uniqueCoins.entrySet().stream()
                        //.sorted(Collections.reverseOrder(Map.Entry.comparingByValue()))
                        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
                        .forEachOrdered(p -> sortedReversed.put(p.getKey(), p.getValue()));

        System.out.println(sortedReversed.entrySet().iterator().next().getValue());
    }
}

import java.io.*;
import java.util.*;

public class Task {
	static final StdIn in = new StdIn();
	static final PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {
		int n = in.nextInt();

		int frequency[] = new int[101];
		Arrays.fill(frequency, 0);

		HashSet<Integer> arr = new HashSet<>();

		int max = -1;
		int ans = 0;
		for (int i = 0; i < n; i++) {
			int num = in.nextInt();
			frequency[num]++;
			arr.add(num);//unique
			if(frequency[num] > max) {
				max = frequency[num];
			}

		}
		ans = (n == arr.size() || 1 == arr.size()) ? n : n-arr.size();

        out.println(max);

		out.close();
    }

    static class Pair {
        int first = 1;
        int second = 2;
    }

    public void fibonacci(int N) {
        boolean arr[] = new boolean[N];
        Arrays.fill(arr, false);
        arr[0] = true;
        if(N>1)
            arr[1] = true;

        Pair p = new Pair();
        for (int i = 3; i <= N; i++) {

            if(p.first + p.second == i) {
                arr[i-1] = true;
                p.first = p.second;
                p.second = i;
            } else {
                arr[i-1] = false;
            }
        }
    }

    public class Solver {
		Solver() {

        }

    }

    static long factorial(long x) {
        if(x <= 1) {
            return 1;
        }
        long res = 2;
        for (int i = 3; i <= x; i++) {
            res = res * i;
        }
        return res;
    }

    static long gcdOfFactorial(long a, long b) {
        if (b == 0)
            return a;
        return gcdOfFactorial(b, a % b);
    }

	static class StdIn {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;
		public StdIn() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public StdIn(InputStream in) {
			try{
				din = new DataInputStream(in);
			} catch(Exception e) {
				throw new RuntimeException();
			}
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public String next() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == ' ' || c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c=read();
			}
			return s.toString();
		}
		public String nextLine() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c = read();
			}
			return s.toString();
		}
		public int nextInt() {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}
		public int[] readIntArray(int n, int os) {
			int[] ar = new int[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextInt()+os;
			return ar;
		}
		public long nextLong() {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}
		public long[] readLongArray(int n, long os) {
			long[] ar = new long[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextLong()+os;
			return ar;
		}
		public double nextDouble() {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');
			if (c == '.')
				while ((c = read()) >= '0' && c <= '9')
					ret += (c - '0') / (div *= 10);
			if (neg)
				return -ret;
			return ret;
		}
		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}
		private byte read() {
			try{
				if (bufferPointer == bytesRead)
					fillBuffer();
				return buffer[bufferPointer++];
			} catch(IOException e) {
				throw new RuntimeException();
			}
		}
		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
}

import java.util.*;

public class Miguel {
    static void process(Scanner ler) {
    }

    public static void main(String[] args) {
        Scanner ler = new Scanner(System.in);
	/*
	int t = ler.nextInt();
	ler.nextLine();
	while (t-- > 0) process(ler);
	*/
	int n = ler.nextInt(), max = 0;
	int arr[] = new int[200];
	int count[] = new int[200];

	for (int i = 0; i < n; i++) {
	    arr[i] = ler.nextInt();
	    count[arr[i]]++;
	    max = count[arr[i]] > max ? count[arr[i]] : max;
	}

	System.out.println(max);
    }
}

import java.util.*;
import java.io.*;
public class Lo
{
    public static void main(String[] args)
    {
        Scanner s  = new Scanner(System.in);
        int n = s.nextInt();
        int[] a = new int[101];
        for(int i=0;i<n;i++)
        {
            a[s.nextInt()]++;
        }
       Arrays.sort(a);
       System.out.println(a[100]);
    }
}

import java.util.*;
import java.lang.*;
import java.io.*;
public class PolycarpsPockets{
	public static void main(String args[])throws IOException{
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(System.out));
		int size = Integer.parseInt(br.readLine());
		String str[] = br.readLine().trim().split("\\s+");
		HashMap<String,Integer> hs = new HashMap<String,Integer>();
		int max = -1;
		for(int i=0;i<size;i++){
			if(hs.containsKey(str[i])){
				hs.put(str[i],hs.get(str[i])+1);
			}
			else{
				hs.put(str[i],1);
			}
			max = Math.max(hs.get(str[i]),max);
		}

		bw.write(max+"\n");
		bw.close();
	}
}

import java.util.*;
public class Main{
    public static void main(String args[]){
        Scanner sc=new Scanner(System.in);
        int size=sc.nextInt();
        HashMap<Integer,Integer> map=new HashMap<>();
        for(int i=0;i<size;i++){
            int temp=sc.nextInt();
            if(map.containsKey(temp)){
                map.put(temp,map.get(temp)+1);
            }
            else map.put(temp,1);
        }
        int min=0;
        for(Map.Entry mapElement: map.entrySet()){
            if((int)mapElement.getValue()>min)min=(int)mapElement.getValue();
        }
        System.out.println(min);
    }
}

import java.util.Scanner;

public class P1 {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);

        String s1 = scanner.next();
        String s2 = scanner.next();

        int maxLength = 0;

        if(s1.equals(s2)) {
            maxLength = 0;

        }
        else if(s1.length() == s2.length()) {
            maxLength = s1.length();
        }
        else{
            if(s1.length() > s2.length()) {
                maxLength = s1.length();
            }
            else {
                maxLength = s2.length();
            }

        }

        if(maxLength < 4) {
            System.out.println("Best Friends Forever");
        }
        else{
            System.out.println(maxLength);
        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author NicolaiNisbeth
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        PolycarpsPockets solver = new PolycarpsPockets();
        solver.solve(1, in, out);
        out.close();
    }

    static class PolycarpsPockets {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt();
            }

            Arrays.sort(arr);

            int max = Integer.MIN_VALUE;
            int cur = 0;
            int j = arr[0];
            for (int i = 0; i < arr.length; i++) {
                cur++;

                if (arr[i] != j) {
                    max = Math.max(max, cur);
                    cur = 0;
                }
                j = arr[i];
            }

            if (cur > 0)
                max = Math.max(max, cur);

            out.println(max);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String firstLine = br.readLine();
        int n = Integer.parseInt(firstLine);
        String[] inputLine = br.readLine().split(" ");
        int[] input = new int[n];
        for (int i = 0; i < n; i++) {
            input[i] = Integer.parseInt(inputLine[i]);
        }
        Arrays.sort(input);
        int max = 1;
        int count = 1;
        for (int i = 0; i < n - 1; i++) {
            if (input[i] == input[i + 1]) {
                count++;
            } else {
                if (max < count) {
                    max = count;
                }
                count = 1;
            }
        }
        if (max < count) {
            max = count;
        }
        count = 1;
        for (int k = max;k<=n ;k++){
            if(n%k==0){
                System.out.println(k);
                break;
            }
        }

    }
}

/*public class main {
    public static void main(String[] str){
        System.out.println(hammingDistance(4,1));
    }

    public static int hammingDistance(int x, int y) {
        int result = x^y;
        String strResult = tenToTwo(result);
        int count = 0;
        for (int i=0; i<strResult.length(); i++){
            if(strResult.charAt(i) == '1'){
                count++;
            }
        }
        return count;
    }

    public static String tenToTwo(int number){
        String result = "";
        while(number > 1) {
            result = number%2 + result;
            number = number/2;
        }
        result = number + result;
        return result;
    }
}*/

import java.util.LinkedList;
import java.util.Scanner;

public class Main{
	public static void main(String agrs[]) {
		Scanner in = new Scanner(System.in);
		while(in.hasNext()) {
			LinkedList<Integer> num = new LinkedList<>();
			int n = in.nextInt();
			for(int i=0;i<n;i++) {
			 num.add(in.nextInt());
			}
			int nu1=0;
			int nu2=0;
			int finda,findb;
			for(int a=0;a<num.size();a++) {
				nu1 = 0;
				for(int b=a;b<num.size()-a;b++) {
					finda = num.get(a);
					findb = num.get(b);
					if(finda == findb)
						nu1 = nu1 + 1;
					if(nu1 >= nu2 )
						nu2 = nu1;
				}
			}
			System.out.println(nu2);
		}
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class v {
    public static void main(String[] args) throws IOException {
        int b = 0;
        int [] ar= new int[101];
       BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
       StringTokenizer tk = new StringTokenizer(in.readLine());
                   String w1 = tk.nextToken();
            int y1 = Integer.parseInt(w1);

       tk = new StringTokenizer(in.readLine());
                    for (int i = 0; i < y1; i++) {
            String w = tk.nextToken();
            int y = Integer.parseInt(w);
            ar[y]++;
        }
                   for (int i = 0; i < ar.length; i++) {
                       System.out.println(ar[i]);

        }
                     int o =ar[0];

        for (int i = 1; i < ar.length; i++) {
            if (ar[i]>o) {
                o=ar[i];
            }

        }
        System.out.println(o);
}}

import java.util.HashMap;
import java.util.Scanner;

public class PolycarpPocket_1003A {
    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
        int max = 0;
        for(int i=0; i<n; i++){
            int ele = s.nextInt();
            if(map.containsKey(ele)){
                int temp = map.get(ele);
                map.put(ele, temp+1);
                if(temp+1 > max){
                    max = temp+1;
                }
            }
            else{
                map.put(ele, 1);
            }
        }
        System.out.println(max);
    }
}

import java.util.Scanner;

public class PolycarpsPockets {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int[] a = new int[n];
		int temp=0;
		for(int i=0;i<n;i++)
		{
			a[i]=scan.nextInt();
		}
		if(n>1)
		{
		for(int i=0;i<n;i++)
		{
			for(int j=i+1;j<n;j++)
			{
				if(a[i]==a[j])
				{
					temp++;
				}
			}
		}
		System.out.println(temp);
		}
		else
		{
			System.out.println("1");
		}
	}

}

import java.util.ArrayList;
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int n = sc.nextInt();
		int[] arr = new int[n];
		ArrayList<Integer> arr2 = new ArrayList<Integer>();
		for(int i=0;i<n;i++)
		{
			arr[i] = sc.nextInt();
		}

		for(int i=0;i<n;i++)
		{
			for(int j =i+1;j<n;j++)
			{
				if(arr[i]==arr[j] )
				{
					if(arr2.contains(arr[i]))
					{

					}
					else
					{
						arr2.add(arr[i]);
					}

				}
			}
		}
		if(arr2.size()==0)
		{
			System.out.println(1);
		}
		else
		{
			System.out.println(arr2.size());
		}

	}

}

import java.util.*;
public class Main {
    public static void main(String[] args) {
        Scanner console = new Scanner(System.in);
        int n = console.nextInt();
        int[] array = new int[n];
        for (int i = 0; i < n; i++) {
          array[i] = console.nextInt();
        }
        int occ = 0;
        int max = 1;
        for (int i = 0; i < n; i++) {
          for (int j = i + 1; j < n; j++) {
            if (array[i] == array[j]) {
              occ++;
            }
          }
        }
        if (occ > max) {
          max = occ;
        }
        System.out.println(max);
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {

        Scanner in = new Scanner(System.in);
        int num = in.nextInt();
        int [] val = new int[num];
        for(int i=0;i<num;i++ )
            val[i] =in.nextInt();

        int [] b= new int[num];
        for(int i=0;i<num;i++)
            b[i]=1;
        int iter=1;
        int j=0;
        for(int i=1; i<val.length;i++){
            if(val[i]==val[i-1]){
                iter++;
                b[j]=iter;
            }
            else
                j++;
            iter=1;
        }

        Arrays.sort(b);
        System.out.println(b[num-1]);

    }
}

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x;
        int[] a = new int[101];
        for(int i = 0; i < n; i++) {
            x = sc.nextInt();
            a[x]++;
        }
        int m = a[0];
        for(int i = 1; i < n;i++) {
            if(a[i] > m)
                m = a[i];
        }
        System.out.println(m);
    }
}

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt(); sc.nextLine();
        List<Integer> list = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            list.add(sc.nextInt());
        }
        sc.nextLine();

        int counter = 1; int max_counter = 1;

        for (int i = 0; i < n-1; i++) {
            if (list.get(i) == list.get(i +1))
                counter++;
            else
                if(counter > max_counter){
                max_counter = counter;
                counter = 1;
            }
        }

        System.out.println(max_counter);

    }
}

/*	Basic import definitions	*/
	import java.util.*;

/*	Basic Class definitions*/
	public class A1003
	{
		public static void main(String[] args)
		{
			Scanner sc = new Scanner(System.in);

			int i , j , k;
			int T,N;

			T = sc.nextInt();
                        int max = 0;
                        int a[] = new int[101];

			for ( i = 0 ; i < T ; i++ )
			{
                            k = sc.nextInt();
                            a[k]++;
			}
                        Arrays.sort(a);
                        System.out.println(a[99]);
		}
	}

//codeforces 700
import java.io.*;
import java.util.*;
import java.util.Arrays;
import static java.lang.System.out;
public class PolycarpPockets
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=new int[n];

        int i,j;
        for(i=0;i<n;i++)
        {
            a[i]=sc.nextInt();
        }//for ends

        Arrays.sort(a);
        int ct=0;
        for(i=0;i<n-1;i++)
        {
            if(a[i]==a[i+1])
            ct++;
        }//for ends
        out.println(ct+1);

    }//main ends
}//class ends

import java.io.*;
import java.util.*;

public class A {
	FastScanner in;
    PrintWriter out;

    void solve() {
    	int T = in.nextInt();
    	int[] a = new int[T];
        for(int i=0;i<T;i++) {
        	int y = in.nextInt();
        	a[y%T]+= 1;
        }
        int max = 0;
        for(int z : a) {
        	max = Math.max(z, max);
        }
        out.println(max);
    }

	public static void main(String[] args) {
        new A().runIO();
    }

	void run() {
        try {
            in = new FastScanner(new File("A.in"));
            out = new PrintWriter(new File("A.out"));
            solve();
            out.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }

    void runIO() {
        in = new FastScanner(System.in);
        out = new PrintWriter(System.out);
        solve();
        out.close();
    }

	class FastScanner {
        BufferedReader br;
        StringTokenizer st;

        public FastScanner(File f) {
            try {
                br = new BufferedReader(new FileReader(f));
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            }
        }

        public FastScanner(InputStream f) {
            br = new BufferedReader(new InputStreamReader(f));
        }

        String next() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return null;
                st = new StringTokenizer(s);
            }
            return st.nextToken();
        }

        boolean hasMoreTokens() {
            while (st == null || !st.hasMoreTokens()) {
                String s = null;
                try {
                    s = br.readLine();
                } catch (IOException e) {
                    e.printStackTrace();
                }
                if (s == null)
                    return false;
                st = new StringTokenizer(s);
            }
            return true;
        }

        int nextInt() {
            return Integer.parseInt(next());
        }

        long nextLong() {
            return Long.parseLong(next());
        }

        double nextDouble() {
            return Double.parseDouble(next());
        }
    }
}

//codeforces 700
import java.io.*;
import java.util.*;
import java.util.Arrays;
import static java.lang.System.out;
public class PolycarpPockets
{
    public static void main(String args[])
    {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int a[]=new int[n];

        int i,j;
        for(i=0;i<n;i++)
        {
            a[i]=sc.nextInt();
        }//for ends

        Arrays.sort(a);

        int ct=0;
        for(i=0;i<n-1;i++)
        {
            if(a[i]==a[i+1])
            ct++;
        }//for ends
        out.println(ct);

    }//main ends
}//class ends

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CodeForces {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int z = scanner.nextInt();
        int[] a = new int[z];
        for(int i=0;i<z;i++) a[i] = scanner.nextInt();
        HashMap<Integer,Integer> map = new HashMap<>();

        for(int x:a) map.put(x,map.getOrDefault(x,0));
        int m = -1, val=0;
        for(Map.Entry k:map.entrySet()){
            if(m>(int)k.getValue()) {
                m = (int) k.getValue();
                val = (int)k.getKey();
            }
        }
        System.out.println(val);
    }
}

import java.util.Scanner;

public class PolycarpsPockets {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int[] a = new int[n];
		int temp=0;
		for(int i=0;i<n;i++)
		{
			a[i]=scan.nextInt();
		}
		if(n>1)
		{
		for(int i=0;i<n;i++)
		{
			for(int j=i+1;j<n;j++)
			{
				if(a[i]==a[j])
				{
					temp++;
					break;
				}
			}
		}
		System.out.println(temp);
		}
		else
		{
			System.out.println("1");
		}
	}

}

//codeforces 700
    import java.io.*;
    import java.util.*;
    import java.util.Arrays;
    import static java.lang.System.out;
    public class PolycarpPockets
    {
        public static void main(String args[])
        {
            Scanner sc=new Scanner(System.in);
            int n=sc.nextInt();
            int a[]=new int[n];
            if(n==1)
            out.println("1");
            else
            {

            int i,org;
            for(i=0;i<n;i++)
            {
                a[i]=sc.nextInt();

            }//for ends

            Arrays.sort(a);

            int ct=0;
            int p=1;
            for(i=0;i<n-1;i++)
            {
                if(a[i]==a[i+1])
                {
                ct++;
                p++;
            }
            }//for ends

            if((n-ct)==1)
            {
                out.println(p);
            }
            else
            {
            out.println(ct);
        }//else ends

        }

        }
    }

import java.util.Scanner;

public class hi {

public static void main(String args[]) {
	Scanner sc=new Scanner(System.in);
	int n=sc.nextInt();
	String s=sc.next();
int max=-1;
for(int i=0;i<s.length();i++)
{
	int count=0;
	for(int j=0;j<s.length();j++)
	{
		if(s.charAt(i)==s.charAt(j))
		{
			count++;
		if(count>max)
			max=count;
		}
	}

}
System.out.println(max);
}
}

/* package codechef; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Codechef
{
	public static void main (String[] args) throws java.lang.Exception
	{

        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
       int max=0;
        int a[]=new int[101];
        int num[]=new int[101];
        int sum=0;
        for(int i=0;i<n;i++){
        a[i]=sc.nextInt();
        num[a[i]]++;
     }
      for(int j=0;j<100;j++){
          if(num[j]>max){
              max=num[j];
          }
      }
      System.out.println(max);

	}
}

//package com.baba;

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        ArrayList<Integer> arr = new ArrayList<>();
        int ans =  0;
        for (int i = 0; i < n; i++) {
            int temp = s.nextInt();
            if (arr.contains(temp)){
                ans++;
            }
            arr.add(temp);
        }
        if (ans==0){
            ans = 1;
        }
        System.out.println(ans);
    }
}

// A. Polycarp's Pocket

import java.util.ArrayList;
import java.util.Collections;
import java.util.Objects;
import java.util.Scanner;

public class CF_1003A {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        ArrayList<Integer> a = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            a.add(input.nextInt());
        }
        Collections.sort(a);

        int max = 1, count = 1;
        for (int i = 0; i < n - 1; i++) {
            int l = a.get(i);
            int r = a.get(i + 1);
            if (Objects.equals(l, r)) {
                count++;
            } else {
                if (count > max) {
                    max = count;
                    count = 1;
                }
            }
        }

        System.out.println(max);

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.StringTokenizer;

public class Solution {

    public static void main(String[] args) {
        FastScanner scan = new FastScanner(System.in);

        int n = scan.nextInt();

        int[] arr = new int[n];
        for (int i = 0; i < n; i++) {
            arr[i]=scan.nextInt();
        }

        Arrays.sort(arr);

//        int max=1;
//
//        int tmp=arr[0];
//
//        int v= 0;
//        for (int i = 0; i < arr.length; i++) {
//
//            if(arr[i]==tmp){
//                v++;
//            }else {
//                tmp=arr[i];
//                if(v>max){
//                    max=v;
//                }
//                v=1;
//            }
//
//        }

        int last = arr[0];
        int numDupes = 1;
        int max=0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] == last) numDupes++;
            else{
                if(numDupes > max)max=numDupes;
                numDupes=1;
                last = arr[i];
            }

        }
        if(max == 0){
            System.out.println(1);
        }else {
            System.out.println(max);
        }

    }

    ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    static class FastScanner {
        private BufferedReader br;
        private StringTokenizer st;

        public FastScanner(InputStream stream) {
            br = new BufferedReader(new InputStreamReader(stream));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public long[] nextLongArray(int n) {
            long[] tab = new long[n];
            for (int i = 0; i < tab.length; i++) {
                tab[i] = nextLong();
            }
            return tab;
        }
    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author NicolaiNisbeth
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        PolycarpsPockets solver = new PolycarpsPockets();
        solver.solve(1, in, out);
        out.close();
    }

    static class PolycarpsPockets {
        public void solve(int testNumber, InputReader in, PrintWriter out) {
            int n = in.nextInt();
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = in.nextInt();
            }

            Arrays.sort(arr);
            int ans = 0;
            int j = arr[0];
            for (int i = 1; i < n; i++) {
                if (arr[i] == j) {
                    ans++;
                }
                j = arr[i];
            }

            if (ans == 0) {
                ans = 1;
            } else if (ans == n - 1)
                ans = n;

            out.println(ans);
        }

    }

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class A1003 {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        int n = in.nextInt();
        Set<Integer> coins = new HashSet<Integer>();
        for (int i = 0; i < n; i++) {
            int coin = in.nextInt();
            if (coins.contains(coin)) {
                System.out.println(2);
                return;
            } else coins.add(coin);
        }
        System.out.println(1);
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public String readLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public char nextChar() {
        return next().charAt(0);
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Football {
public static void main(String[] args) {
   Scanner sc=new Scanner (System.in);
   int n=sc.nextInt();
  int  ar[]=new int[n];
  String st1;
  String st2=new String();
  int x=1;
   for(int i=0;i<n;i++)
   {
       ar[i]=sc.nextInt();

   }
   Arrays.sort(ar);

   int max=1;
   for(int i=0;i<n-1;i++)
   {
    if(ar[i+1]==ar[i])
    {
        ++x;
    }
    else
    {
        if(x>max)
        {
            max=x;
            x=0;
        }

    }
}
    System.out.println(Math.max(x, max));

   }

}

	import java.util.*;
	import java.io.*;
	import java.text.*;
	import java.math.*;

	public class Codeforces{
		boolean multipleTC=false;
		void solve( int tc )throws Exception{
			int n=ni(), ans=0, max=0;
			int[]a = new int[105];
			for( int i=0; i<n; i++ ) a[ni()]++;
			for( int i=0; i<a.length; i++ ) ans=Math.max(a[i], max);
			pn(max);
		}

		void run() throws Exception{
			in = new FastReader();
			out = new PrintWriter( System.out );
			for( int i=1, t=(multipleTC)?ni():1 ; i<=t; i++ )solve(i);
			out.flush();
			out.close();
		}

		public static void main( String[]args )throws Exception{
			new Codeforces().run();
		}

		FastReader in;
		PrintWriter out;

		long[]la( int n )throws Exception{ long[]a=new long[n]; for( int i=0; i<n; i++ )a[i]=nl(); return a; }
		int[]ia( int n )throws Exception{ int[]a=new int[n]; for( int i=0; i<n; i++ )a[i]=ni(); return a; }
		int gcd( int a, int b ){ return (b==0)?a:gcd(b,a%b); }
		void p(Object o){ out.print(o); }
		void pn(Object o){ out.println(o); }
		void pni(Object o){ out.println(o); out.flush(); }
		String n(){ return in.next(); }
		int ni() throws Exception{ return Integer.parseInt(in.next()); }
		long nl() throws Exception{ return Long.parseLong(in.next()); }

		class FastReader{
			BufferedReader br;
			StringTokenizer st;
			public FastReader(){
				br=new BufferedReader(new InputStreamReader(System.in));
			}
			String next(){
				while( st==null || !st.hasMoreElements() ){
					try{
						st = new StringTokenizer( br.readLine() );
					}catch( IOException e ){
						e.printStackTrace();
					}
				}return st.nextToken();
			}
			String nextLine(){
				String str = "";
				try{
					str = br.readLine();
				}catch( IOException e ){
					e.printStackTrace();
				}return str;
			}
		}
	}

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner(System.in);

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		int n = sc.nextInt();
		int[] arr = new int[n];

		for(int i=0;i<n;i++)
		{
			arr[i] = sc.nextInt();
		}
		Arrays.sort(arr);
		int last = arr[0];
		int numDupes = 1;
		for (int i = 1; i < arr.length; i++) {
		   if (arr[i] == last) numDupes++;
		   last = arr[i];
		}
		System.out.println(numDupes);

	}

}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.util.Arrays;
import java.io.BufferedWriter;
import java.io.Writer;
import java.io.OutputStreamWriter;
import java.util.InputMismatchException;
import java.io.IOException;
import java.io.InputStream;

/**
 * Built using CHelper plug-in
 * Actual solution is at the top
 *
 * @author Rishabhdeep Singh
 */
public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        OutputWriter out = new OutputWriter(outputStream);
        TaskA solver = new TaskA();
        solver.solve(1, in, out);
        out.close();
    }

    static class TaskA {
        public void solve(int testNumber, InputReader in, OutputWriter out) {
            int n = in.nextInt();
            int[] cnt = new int[101];
            Arrays.fill(cnt, 0);
            for (int i = 0; i < n; i++) {
                cnt[in.nextInt()]++;
            }
            long sum = 0;
            for (int i = 0; i < 101; i++) {
                sum += cnt[i];
            }
            out.print(sum);
        }

    }

    static 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 close() {
            writer.close();
        }

        public void print(long i) {
            writer.print(i);
        }

    }

    static class InputReader {
        private InputStream stream;
        private byte[] buf = new byte[1024];
        private int curChar;
        private int numChars;
        private InputReader.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 nextInt() {
            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 boolean isSpaceChar(int c) {
            if (filter != null) {
                return filter.isSpaceChar(c);
            }
            return isWhitespace(c);
        }

        public static boolean isWhitespace(int c) {
            return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
        }

        public interface SpaceCharFilter {
            public boolean isSpaceChar(int ch);

        }

    }
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        A a = new A(in, out);
        a.run();
        out.close();
    }

    public static class A{

        InputReader in ;
        PrintWriter out;

        public A(InputReader in, PrintWriter out) {
            this.in = in;
            this.out = out;
        }

        public void run(){
            int n = in.nextInt();
            List<Integer> coins = new ArrayList<>(n);
            IntStream.range(0,n).forEach( e-> coins.add(0));
            IntStream.range(0,n).forEach( e-> {
                int num = in.nextInt();
                coins.set(num,coins.get(num)+1);
            });

            int answer = IntStream.range(0,n).max().getAsInt();
            out.println(answer);

        }
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;
import java.util.LinkedList;
import java.util.List;

public class Main {

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int n;
        n = sc.nextInt();
        int arr[] = new int[n];
        for (int i = 0; i < n; i++)
            arr[i] = sc.nextInt();
        Arrays.sort(arr);
        int count = 1;
        for (int i = 0; i < n - 1; i++) {
            if (arr[i] == arr[i + 1])
                count++;

        }

        System.out.println(count);
    }
}

import java.util.*;
import java.io.*;
import java.text.*;
import java.math.*;

public class Codeforces{
	boolean multipleTC=false;
	void solve( int tc )throws Exception{
		int n=ni(), ans=0;
		boolean[]b = new boolean[105];
		for( int i=0; i<n; i++ ){
			int val=ni();
			if( !b[val] ) b[val]=true;
			else ans++;
		}pn(ans);
	}

	void run() throws Exception{
		in = new FastReader();
		out = new PrintWriter( System.out );
		for( int i=1, t=(multipleTC)?ni():1 ; i<=t; i++ )solve(i);
		out.flush();
		out.close();
	}

	public static void main( String[]args )throws Exception{
		new Codeforces().run();
	}

	FastReader in;
	PrintWriter out;

	long[]la( int n )throws Exception{ long[]a=new long[n]; for( int i=0; i<n; i++ )a[i]=nl(); return a; }
	int[]ia( int n )throws Exception{ int[]a=new int[n]; for( int i=0; i<n; i++ )a[i]=ni(); return a; }
	int gcd( int a, int b ){ return (b==0)?a:gcd(b,a%b); }
	void p(Object o){ out.print(o); }
	void pn(Object o){ out.println(o); }
	void pni(Object o){ out.println(o); out.flush(); }
	String n(){ return in.next(); }
	int ni() throws Exception{ return Integer.parseInt(in.next()); }
	long nl() throws Exception{ return Long.parseLong(in.next()); }

	class FastReader{
		BufferedReader br;
		StringTokenizer st;
		public FastReader(){
			br=new BufferedReader(new InputStreamReader(System.in));
		}
		String next(){
			while( st==null || !st.hasMoreElements() ){
				try{
					st = new StringTokenizer( br.readLine() );
				}catch( IOException e ){
					e.printStackTrace();
				}
			}return st.nextToken();
		}
		String nextLine(){
			String str = "";
			try{
				str = br.readLine();
			}catch( IOException e ){
				e.printStackTrace();
			}return str;
		}
	}
}

import java.util.*;
import java.util.Scanner;
public class polycarppocket {
     public static void main(String[] args) {

     Scanner br = new Scanner(System.in);

     int x = 0;
     int a = br.nextInt();
     int[] y = new int[100];

     for(int i = 0; i < a; i++) {
     int z = br.nextInt() - 1;
     y[z]++;

     if (y[z] > x) x = y[z];
     }

     System.out.println(y);
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String firstLine = br.readLine();
        int n = Integer.parseInt(firstLine);
        String[] inputLine = br.readLine().split(" ");
        int[] input = new int[n];
        for (int i = 0; i < n; i++) {
            input[i] = Integer.parseInt(inputLine[i]);
        }
        Arrays.sort(input);
        int max = 1;
        int count = 1;
        for (int i = 0; i < n - 1; i++) {
            if (input[i] == input[i + 1]) {
                count++;
            } else {
                if (max < count) {
                    max = count;
                }
                count = 1;
            }
        }
        for (int k = max;k<=n ;k++){
            if(n%k==0){
                System.out.println(k);
                break;
            }
        }

    }
}

/*public class main {
    public static void main(String[] str){
        System.out.println(hammingDistance(4,1));
    }

    public static int hammingDistance(int x, int y) {
        int result = x^y;
        String strResult = tenToTwo(result);
        int count = 0;
        for (int i=0; i<strResult.length(); i++){
            if(strResult.charAt(i) == '1'){
                count++;
            }
        }
        return count;
    }

    public static String tenToTwo(int number){
        String result = "";
        while(number > 1) {
            result = number%2 + result;
            number = number/2;
        }
        result = number + result;
        return result;
    }
}*/

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class Problem1 {

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		Map<Integer,Integer>coinMap = new HashMap<Integer,Integer>();
		for(int i=0;i<n;i++){
			int val = sc.nextInt();
			int count=0;
			if(!coinMap.containsKey(val)){
				coinMap.put(val,count);
				continue;
			}
			coinMap.put(val,coinMap.get(val)+1);

		}
		int max=1;
		for (Integer val : coinMap.keySet()) {
			if(max >=coinMap.get(val)){
				continue;
			}
			max = val;
		}
		System.out.println(max);
		sc.close();
	}
}

/* package whatever; // don't place package name! */

import java.util.*;
import java.lang.*;
import java.io.*;

/* Name of the class has to be "Main" only if the class is public. */
public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		ArrayList<HashSet<Integer>> arr= new ArrayList<HashSet<Integer>>();
		BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );
		int n = Integer.parseInt( br.readLine() );
		int repetidos = 0;
		String z[] = br.readLine().split( "\\s" );

		for( int i = 0; i < n ; i++ ){

			boolean ADDED = false;
			for( HashSet<Integer> hs : arr ){
				if( !hs.contains( Integer.parseInt( z[i] ) ) ){
					hs.add( Integer.parseInt( z[i] ) );
					ADDED = true;
				}
			}

			if( !ADDED ){
				HashSet<Integer> temp = new HashSet<Integer>();
				temp.add( Integer.parseInt( z[i] ) );
				arr.add( temp );
			}
		}

		System.out.println( arr.size() );
	}
}

import java.util.Scanner;

public class PolycarpsPockets {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int[] a = new int[n];
		for(int i=0;i<n;i++)
		{
			a[i]=scan.nextInt();
		}
		if(n>1)
		{
			n=n/2;
			System.out.println(n-1);
		}
		else
		{
			System.out.println("1");
		}
	}

}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class YaponskiiKrosvord {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int n = sc.nextInt();

		int mon = 0;

		Map<Integer, Integer> map = new HashMap<>();

		for (int i = 0; i < n; i++) {
			mon = sc.nextInt();
			map.put(mon, map.getOrDefault(mon, 0) + 1);
		}

		int count = 0;
		for(Map.Entry<Integer, Integer> pair : map.entrySet()) {
			if(pair.getValue() > 1) {
				count+=pair.getValue() - 1;
			}else {
				count++;
			}
		}

	     System.out.println(count);

	}

}

import java.util.ArrayList;
import java.util.Scanner;

public class codeforces {

  public static void main(String[] args) {
  Scanner sc = new Scanner(System.in);
  int n=sc.nextInt();
  int t=0;
  int no=0;
  ArrayList<Integer> c = new ArrayList<Integer>();
  for(int i=0;i<n;i++){
  t=sc.nextInt();
    if(!c.contains(t)){
      c.add(t);
      c.add(1);
    }
    else {
    c.set(c.indexOf(t)+1,c.get(c.indexOf(t)+1)+1);
    }
  }
  for (int i=1;i<c.size();i+=2){
    if(c.get(i)>no){
      no=c.get(i);
    }
  }
  System.out.print(no);

  }
}

import java.util.*;
public class gh {

	public static void main(String[] args) {
		Scanner in=new Scanner(System.in);
		int z;
		int n=in.nextInt();
		int arr[]=new int[n];
		for(int i=0;i<n;i++)
		{
			arr[i]=in.nextInt();
		}
			int max=0,c=0;

			for(int i=0;i<n&&arr[i]!=-1;i++)
				{
				c=0;

				for(int j=i+1;j<n;j++)

					if(arr[i]==arr[j])
					{
						c++;
						arr[j]=-1;
					}
				arr[i]=-1;
				if(c>max)
					max=c;
				}

			System.out.println(max+1);

	}

}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.nio.Buffer;
import java.util.*;

public class Pair {

    static class FastReader {
        private BufferedReader br;
        private StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        public String next() {
            while (st == null || !st.hasMoreElements()) {
                try {
                    st = new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            return st.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public String nextLine() {
            String str = "";
            try {
                str = br.readLine();
            } catch (IOException e) {
                e.printStackTrace();
            }
            return str;
        }
    }
    public static int fact(int n){
        int fact =1;
        for(int i=1;i<=n;i++){
            fact = fact*i;
        }
        return fact;
    }
    public static void main (String[] args) throws Exception{
        try{
            FastReader sc = new FastReader();
            int n = sc.nextInt();
            int[]arr = new int[n];
            for(int i=0;i<arr.length;i++){
                arr[i] = sc.nextInt();
            }
            int count=0;
            Arrays.sort(arr);
            for(int i=0;i<arr.length-1;i++){
                if(arr[i]==arr[i+1]){
                    count++;
                }
            }
            if(count>=1){
                System.out.println(2);
            }
            else if(count==n-1){
                System.out.println(n);
            }
            else{
                System.out.println(1);
            }

        }
        catch(Exception e){

        }
    }
}

//package cp_bonus1;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.Arrays;

public class q1 {

	public static void main(String[] args) throws IOException{
		// TODO Auto-generated method stub
		Reader.init(System.in);
		int no=Reader.nextInt();
		int[] arr=new int[101];
		int flag=0;
		for(int i=0;i<no;i++) {
			int s=Integer.parseInt(Reader.nextLine());
			if(arr[s]==0) {
				arr[s]++;
			}
			else {
				flag++;
			}
		}
		if(flag==0) {
			System.out.println(1);
		}
		else {
			System.out.println(2);
		}

	}

}

class Reader {
    static BufferedReader reader;
    static StringTokenizer tokenizer;

    /** call this method to initialize reader for InputStream */
    static void init(InputStream input) {
        reader = new BufferedReader(
                     new InputStreamReader(input) );
        tokenizer = new StringTokenizer("");
    }

    /** get next word */
    static String nextLine() throws IOException {
        while ( ! tokenizer.hasMoreTokens() ) {
            //TODO add check for eof if necessary
            tokenizer = new StringTokenizer(
                   reader.readLine() );
        }
        return tokenizer.nextToken();
    }

    static int nextInt() throws IOException {
        return Integer.parseInt( nextLine() );
    }
    static long nextLong() throws IOException {
    		return Long.parseLong(nextLine());
    }

    static double nextDouble() throws IOException {
        return Double.parseDouble( nextLine() );
    }

    static float nextFloat() throws IOException {
    	return Float.parseFloat( nextLine() );
    }
    static int[] nextIntArray(int length) throws IOException {
    	int[] arr = new int[length];
    	for (int i=0; i<length; i++) {
    		arr[i] = Integer.parseInt( nextLine() );
    	}
    	return arr;
    }
    static long[] nextLongArray(int length) throws IOException {
    	long[] arr = new long[length];
    	for (int i=0; i<length; i++) {
    		arr[i] = Long.parseLong( nextLine() );
    	}
    	return arr;
    }

}

import java.util.*;
import java.io.*;
public class file{
    public static void main(String[] args){
        Scanner scan = new Scanner(System.in);
        int n = scan.nextInt();
        int[] arr = new int[n];
        for(int i=0; i<n; i++){
            arr[i] = scan.nextInt();
        }
        Arrays.sort(arr);
        int result =  1;
        int count = 1;
        int x = arr[0];
        for(int j=1; j<n; j++){
            if(x==arr[j]){
                count++;
                x=arr[j];
            }else{
                x=arr[j];
                if(count>result){
                    result=count;
                    count=1;
                }
            }
    }
    if(count>result){
                    result=count;
                    //count=1;
                }
    System.out.println(result);
}
}

// A. Polycarp's Pocket

import java.util.ArrayList;
import java.util.Collections;
import java.util.Objects;
import java.util.Scanner;

public class CF_1003A {

    public static void main(String[] args) {
        Scanner input = new Scanner(System.in);
        int n = input.nextInt();
        ArrayList<Integer> a = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            a.add(input.nextInt());
        }
        Collections.sort(a);

        int max = 1, count = 1;
        for (int i = 0; i < n - 1; i++) {
            int l = a.get(i);
            int r = a.get(i + 1);
            if (Objects.equals(l, r)) {
                count++;
            } else {
                if (count > max) {
                    max = count;
                    count = 1;
                }
            }
        }

        System.out.println(max);

    }
}

import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class YaponskiiKrosvord {

	public static void main(String[] args) {

		Scanner sc = new Scanner(System.in);

		int n = sc.nextInt();

		int mon = 0;

		Map<Integer, Integer> map = new HashMap<>();

		for (int i = 0; i < n; i++) {
			mon = sc.nextInt();
			map.put(mon, map.getOrDefault(mon, 0) + 1);
		}

		int count = 0;
		for(Map.Entry<Integer, Integer> pair : map.entrySet()) {
			if(pair.getValue() > 1 && map.size() != 1) {
				count+=pair.getValue() - 1;
			}if(map.size() == 1 && pair.getValue() > 1) {
				count = pair.getValue();
			}if(map.size() == 1 && pair.getValue() == 1) {
				count++;
			}

		}

	     System.out.println(count);

	}

}

import java.util.Scanner;

public class PolycarpsPockets {

	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		int n=scan.nextInt();
		int[] a = new int[n];
		int temp=0;
		for(int i=0;i<n;i++)
		{
			a[i]=scan.nextInt();
		}
		if(n%2==0)
		{
			temp=n/2;
			System.out.println(temp-1);
		}
		else
		{
			System.out.println("1");
		}
	}

}

import java.util.Scanner;

public class PolycarpsPockets {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
Scanner scan = new Scanner(System.in);
int x= scan.nextInt();
int [] A= new int[x];
for(int i=0; i<x; i++) {
	A[i]= scan.nextInt();
}
boolean flag = false;
int sum=1;
int max=0;
for(int i=0; i<x-1; i++) {
	sum=1;
	for(int j=i+1; j<x; j++) {
		if(A[i]== A[j]) {
			flag = true;
		sum++;
		}
	}
	if(sum>max)
		max=sum;
}
if(flag)

	System.out.println(max);
	}

}

import java.util.*;

public class Watermelon
{
    public static void main(String[] args)
    {
    	Scanner sc = new Scanner(System.in);
    	int n = sc.nextInt();
    	int a[] = new int[n];
    	for(int i=0; i<n; i++)
    		a[i] = sc.nextInt();

    	int c = 1;
    	Arrays.parallelSort(a);
    	for(int i=1; i<n; i++)
    	{
    		if(a[i]==a[i-1])
    			c++;
    	}
    	if(c==3)
    		System.out.println(2);
    	else
    		System.out.println(c);
    }
}

//package codeforce.problemsets;

import java.lang.reflect.Array;
import java.util.*;
import java.util.stream.Collector;
import java.util.stream.Collectors;

public class PolycarpPockets {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int numberOfCoins = Integer.parseInt(scanner.nextLine());
        String [] valuesOfCoins = scanner.nextLine().split(" ");

        //Group string array ["1", "2", "2", "3"] convert to {"1": {"1"}, "2": {"2", "2"}, "3":"3"}
        Map<Object, List<String>> uniqueCoins = Arrays.stream(valuesOfCoins).collect(Collectors.groupingBy(i -> i));
        System.out.println(uniqueCoins.size());

    }
}

import java.util.*;
public class cryptography {

	public static void main(String[] args) {
		Scanner leer=new Scanner(System.in);
		int n=leer.nextInt();
		int v[]=new int[n];
		int c=1;
		for(int i=0; i<n; i++) {
			v[i]=leer.nextInt();
		}
		Arrays.sort(v);
		int max=0;
		for(int i=0; i<n-1; i++) {
			if(v[i]==v[i+1]) {
				c++;
			}
			else{
				max=Math.max(max, c);
				c=1;
			}
		}
		System.out.println(max);

	}

}

import java.util.*;

public class Watermelon
{
    public static void main(String[] args)
    {
    	Scanner sc = new Scanner(System.in);
    	int n = sc.nextInt();
    	int a[] = new int[n];
    	for(int i=0; i<n; i++)
    		a[i] = sc.nextInt();

    	int c = 1;
    	Arrays.parallelSort(a);
    	for(int i=1; i<n; i++)
    	{
    		if(a[i]==a[i-1])
    			c++;
    	}
    	System.out.println(n/c);
    }
}

import java.io.*;
import java.util.*;

public class Task {
	static final StdIn in = new StdIn();
	static final PrintWriter out = new PrintWriter(System.out);

	public static void main(String[] args) {
		int n = in.nextInt();

		HashSet<Integer> arr = new HashSet<>();

		int ans = 0;
		for (int i = 0; i < n; i++) {
			int num = in.nextInt();
			arr.add(num);//unique

		}
		ans = (n == arr.size() || 1 == arr.size()) ? n : n-arr.size();

        out.println(ans);

		out.close();
    }

    static class Pair {
        int first = 1;
        int second = 2;
    }

    public void fibonacci(int N) {
        boolean arr[] = new boolean[N];
        Arrays.fill(arr, false);
        arr[0] = true;
        if(N>1)
            arr[1] = true;

        Pair p = new Pair();
        for (int i = 3; i <= N; i++) {

            if(p.first + p.second == i) {
                arr[i-1] = true;
                p.first = p.second;
                p.second = i;
            } else {
                arr[i-1] = false;
            }
        }
    }

    public class Solver {
		Solver() {

        }

    }

    static long factorial(long x) {
        if(x <= 1) {
            return 1;
        }
        long res = 2;
        for (int i = 3; i <= x; i++) {
            res = res * i;
        }
        return res;
    }

    static long gcdOfFactorial(long a, long b) {
        if (b == 0)
            return a;
        return gcdOfFactorial(b, a % b);
    }

	static class StdIn {
		final private int BUFFER_SIZE = 1 << 16;
		private DataInputStream din;
		private byte[] buffer;
		private int bufferPointer, bytesRead;
		public StdIn() {
			din = new DataInputStream(System.in);
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public StdIn(InputStream in) {
			try{
				din = new DataInputStream(in);
			} catch(Exception e) {
				throw new RuntimeException();
			}
			buffer = new byte[BUFFER_SIZE];
			bufferPointer = bytesRead = 0;
		}
		public String next() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == ' ' || c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c=read();
			}
			return s.toString();
		}
		public String nextLine() {
			int c;
			while((c=read())!=-1&&(c==' '||c=='\n'||c=='\r'));
			StringBuilder s = new StringBuilder();
			while (c != -1)
			{
				if (c == '\n'||c=='\r')
					break;
				s.append((char)c);
				c = read();
			}
			return s.toString();
		}
		public int nextInt() {
			int ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');

			if (neg)
				return -ret;
			return ret;
		}
		public int[] readIntArray(int n, int os) {
			int[] ar = new int[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextInt()+os;
			return ar;
		}
		public long nextLong() {
			long ret = 0;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');
			if (neg)
				return -ret;
			return ret;
		}
		public long[] readLongArray(int n, long os) {
			long[] ar = new long[n];
			for(int i=0; i<n; ++i)
				ar[i]=nextLong()+os;
			return ar;
		}
		public double nextDouble() {
			double ret = 0, div = 1;
			byte c = read();
			while (c <= ' ')
				c = read();
			boolean neg = (c == '-');
			if (neg)
				c = read();
			do
				ret = ret * 10 + c - '0';
			while ((c = read()) >= '0' && c <= '9');
			if (c == '.')
				while ((c = read()) >= '0' && c <= '9')
					ret += (c - '0') / (div *= 10);
			if (neg)
				return -ret;
			return ret;
		}
		private void fillBuffer() throws IOException {
			bytesRead = din.read(buffer, bufferPointer = 0, BUFFER_SIZE);
			if (bytesRead == -1)
				buffer[0] = -1;
		}
		private byte read() {
			try{
				if (bufferPointer == bytesRead)
					fillBuffer();
				return buffer[bufferPointer++];
			} catch(IOException e) {
				throw new RuntimeException();
			}
		}
		public void close() throws IOException {
			if (din == null)
				return;
			din.close();
		}
	}
}

import java.util.*;
public class work {
    public static void main(String args[]) {
        Scanner scan = new Scanner(System.in);
        int numOfCoins = scan.nextInt();
        int [] Values = new int[numOfCoins];
        for(int i = 0; i<numOfCoins; i++){
            Values[i] = scan.nextInt();
        }
        Arrays.sort(Values);
        if (numOfCoins == 1){
            System.out.println(numOfCoins);
            return;
        }
        int counter = 0;
        if(Values[Values.length-2]==Values[Values.length-1]){
            counter++;
        }
        for(int i = 0; i<Values.length-1; i++){
            if(Values[i] == Values[i+1] ){
                counter++;

            }
        }
        System.out.print(counter);

    }
}

import java.util.*;
//import java.Arrays.*;

public class HelloWorld{

     public static void main(String []args){

        int n,i,sum=0,max=1;
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();

        int[] a=new int [n];
        for(i=0;i<n;i++)
        {
            a[i]=sc.nextInt();
        }
        Arrays.sort(a);
        for(i=1;i<n;i++)
        {
            if(a[i]==a[i-1])
            {
                sum++;
            }
            if(sum>max)
            {
                max=sum;
            }
        }

        System.out.println(max);
     }
}

import java.util.*;
import java.lang.*;
import java.io.*;

public class Main
{
	public static void main (String[] args) throws java.lang.Exception
	{
		HashSet<Integer> ht = new HashSet<Integer>();
		BufferedReader br = new BufferedReader( new InputStreamReader( System.in ) );
		int n = Integer.parseInt( br.readLine() );
		int repetidos = 0;
		String z[] = br.readLine().split( "\\s" );

		for( int i = 0; i < n ; i++ ){
			if( ht.contains( Integer.parseInt( z[i] ) ) )
				repetidos++;
			else
				ht.add( Integer.parseInt( z[i] ) );
		}

		System.out.println( repetidos );
	}
}

import java.util.*;

public class Lo
{
    /*FAtt gyi bbhai*/

    public static void main(String[] args)
    {
    	Scanner sc = new Scanner(System.in);
    	int p = sc.nextInt();
    	int c=0;
    	int[] a = new int[p];
    	for(int i=0;i<p;i++)
    	{
    		a[i] = sc.nextInt();
    	}
    	Arrays.sort(a);
    	if(p>1)
    	{
	    	for(int i=1;i<p;i++)
	    	{
	    		if(a[i]==a[i-1])
	    		{
	    			c++;
	    		}
	    	}
	    	System.out.println(c);
	    }

    	if(p==1)
    	{
    		System.out.println(1);
    	}

    }
}

import java.util.Scanner;
public class Solution4 {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		Solution4 tr = new Solution4();
		tr.test(sc);
		sc.close();
	}
	void test(Scanner sc){
		int N = sc.nextInt();
		int[] in = new int[N];
		if(N==1){
			System.out.println(1);
			return;
		}
		int max=1;
		int same=1;
		in[0]=sc.nextInt();
		for (int i = 1; i < in.length; i++) {
			in[i]=sc.nextInt();
			if(in[i]==in[i-1]){
				same++;
			}else{
				same=1;
			}
			if(same > max){
				max=same;
			}
		}
		System.out.println(max);
/*		if(N==2){
			if(in[0]!=in[1]){
				System.out.println(2);
				return;
			}
			System.out.println(1);
			return;
		}*/

	}
}

/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
import java.util.*;
public class Main
{
	public static void main(String[] args) {
		     int a1=0;
	        int count=1;
	        int pocket=1;
		    Scanner sc=new Scanner(System.in);
		    int n=sc.nextInt();
		    int a[]=new int[n];
		    for(int i=0;i<n;i++)
		        {
		            a[i]=sc.nextInt();
		        }
		        Arrays.sort(a);
		        for(int i=0;i<n-1;i++)
		            {
		                if(a[i]==a[i+1])
		                    {
		                        count++;
		                    }
		                    else
		                        {
		                            if(count<=pocket)
		                            {
		                                pocket=pocket;
		                            }
		                            else
		                            {
		                            pocket=count;
		                            count=1;
		                            }

		                            }
		            }
		            System.out.println(pocket);
	}
}

import java.util.LinkedList;
import java.util.Scanner;

public class Main{
	public static void main(String agrs[]) {
		Scanner in = new Scanner(System.in);
		while(in.hasNext()) {
			LinkedList<Integer> num = new LinkedList<>();
			int n = in.nextInt();
			for(int i=0;i<n;i++) {
			 num.add(in.nextInt());
			}
			int nu1=0;
			int nu2=0;
			int finda,findb;
			for(int a=0;a<num.size();a++) {
				nu1 = 0;
				for(int b=a;b<num.size()-a;b++) {
					finda = num.get(a);
					findb = num.get(b);
					if(finda == findb)
						nu1 = nu1 + 1;
					if(nu1 >= nu2 )
						nu2 = nu1;
				}
			}
			System.out.println(nu2);
		}
	}
}

/******************************************************************************

Welcome to GDB Online.
GDB online is an online compiler and debugger tool for C, C++, Python, Java, PHP, Ruby, Perl,
C#, VB, Swift, Pascal, Fortran, Haskell, Objective-C, Assembly, HTML, CSS, JS, SQLite, Prolog.
Code, Compile, Run and Debug online from anywhere in world.

*******************************************************************************/
import java.util.*;
public class Main
{
	public static void main(String[] args) {
		     int a1=0;
	        int count=1;
	        int pocket=1;
		    Scanner sc=new Scanner(System.in);
		    int n=sc.nextInt();
		    int a[]=new int[n];
		    for(int i=0;i<n;i++)
		        {
		            a[i]=sc.nextInt();
		        }
		        Arrays.sort(a);
		        for(int i=0;i<n-1;i++)
		            {
		                if(a[i]==a[i+1])
		                    {
		                        count++;
		                    }
		                    else
		                        {
		                            if(count<pocket)
		                            {
		                                pocket=pocket;
		                            }
		                            else if(count>=pocket)
		                            {
		                            pocket=count;
		                            count=1;
		                            }

		                            }
		            }
		            if(count>pocket)
		                {
		                    pocket=count;
		                }
		            System.out.println(pocket);
	}
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author ASUS-PC
 */
public class Main {
    public static void main(String[] args) {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int nInput = 0;
        long[] number= null;
        try {
            nInput = Integer.parseInt(br.readLine());
            String[] data = br.readLine().split(" ");
            number = new long[nInput];
            for(int i = 0;i<nInput;i++){
                number[i] = Long.parseLong(data[i]);
            }
        } catch (IOException | NumberFormatException e) {
        }

        for(int i = 0;i<nInput;i++){
            for(int j = i;j<nInput;j++){
                if(number[i]>number[j]){
                    long temp = number[i];
                    number[i] = number[j];
                    number[j] = temp;
                }
            }
        }
        int count = 1;
        int maxCount = 0;
        if(nInput == 1){
            System.out.println("1");
        }
        else{
            for(int i =0;i<nInput-1;i++){
                if(number[i] == number[i+1]){
                    count+=1;
                }
                else{
                    if(maxCount<count){
                        maxCount = count;
                    }
                    count = 1;
                }
            }

            System.out.println(maxCount);
        }
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int num = in.nextInt();
    int [] value = new int [num];

    for (int i=0; i<num;i++)
        value[i]= in.nextInt();

        Arrays.sort(value);
        int finall =1;
        int iter =1;
        for (int i=1;i< value.length;i++){
            if(value[i]== value[i-1])
                iter++;
            else {
                if (iter > finall)
                    finall = iter;
                iter = 1;
            }

            }

            System.out.println(finall);

        }

    }

//package com.baba;

import java.util.ArrayList;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
        Scanner s = new Scanner(System.in);
        int n = s.nextInt();
        ArrayList<Integer> arr = new ArrayList<>();
        int ans =  0;
        for (int i = 0; i < n; i++) {
            int temp = s.nextInt();
            if (arr.contains(temp)){
                ans++;
            }
            arr.add(temp);
        }
        if (ans==0){
            ans = 1;
        }
        System.out.println(ans);
    }
}

import java.util.*;
import java.io.*;

public class Main{

    public static void main(String[] args){
        Scanner in = new Scanner(System.in);

            //array input
            int N = in.nextInt();
            int[] arr = new int[N];
            int[] frq = new int[100];
            for(int i=0 ; i<N ; i++){
                arr[i] = in.nextInt();
                frq[arr[i]-1]++;
            }
            int count = 0;
            for(int i =0; i<N ; i++){
                if(count<frq[i]) count = frq[i];
            }
            System.out.println(count);

        }
    }

import java.util.HashSet;
import java.util.Scanner;

public class Codeforces1003A {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        HashSet<Integer> a = new HashSet<>();
        int kol = 1;
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            if (a.contains(x)) {
                kol++;
            } else {
                a.add(x);
            }
        }
        System.out.println(kol);
        in.close();
    }
}

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CodeForces {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int z = scanner.nextInt();
        int[] a = new int[z];
        for(int i=0;i<z;i++) a[i] = scanner.nextInt();
        HashMap<Integer,Integer> map = new HashMap<>();

        for(int x:a) map.put(x,map.getOrDefault(x,0));
        int m = -1, val=0;
        for(Map.Entry k:map.entrySet()){
            if(m>(int)k.getValue()) {
                m = (int) k.getValue();
                val = (int)k.getKey();
            }
        }
        System.out.println(val);
    }
}

import java.io.*;
import java.util.*;

public class Solution{
    public static void main(String args[]){
        int n;
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        int a[] = new int[n];
        for(int i = 0;i < n;i++){
            a[i] = sc.nextInt();
        }
        Arrays.sort(a);
        int count = 1;
        for(int i = 0;i < n;i++){
            count = 1;
            for(int j = 1;j < n;j++){
                 if(a[i] == a[j]){
                    count = count + 1;
                 }
             }

        }
        if(count > 0)
            System.out.println(count);
    }
}

import java.io.IOException;
import java.util.Scanner;

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */

/**
 *
 * @author kinan
 */
public class Pockets {

    public static void main(String[] args) throws IOException {

        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int [] f = new int[n];

        for (int i=0;i<n;i++){
            f[i]= Integer.parseInt(scanner.next());
        }

   int count = 1, tempCount;

  int temp;
  for (int i = 0; i < n-1; i++)
  {
    temp = f[i];

    if (f[0] ==f[1]){
    tempCount = 1;}
    else tempCount=0;
    for (int j = 1; j < n; j++)
    {
      if (temp == f[j]) {
          tempCount++;
      }
    }
    if (tempCount > count)
    {

      count = tempCount;
    }

}

     System.out.print(count);
    }

}

//package JCFULY3;

import java.io.*;
import java.util.*;

public class Q1{

    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader() {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(System.in), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }
        public char nextChar() {
            return next().charAt(0);
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

        public long nextLong() {
            return Long.parseLong(next());
        }

        public double nextDouble() {
            return Double.parseDouble(next());
        }

        public int[] nextIntArr(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextInt();
            }
            return arr;
        }

        public Integer[] nextIntegerArr(int n) {
            Integer[] arr = new Integer[n];
            for (int i = 0; i < n; i++) {
                arr[i] = new Integer(this.nextInt());
            }
            return arr;
        }

        public int[][] next2DIntArr(int n, int m) {
            int[][] arr = new int[n][m];
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    arr[i][j] = this.nextInt();
                }
            }
            return arr;
        }

        public int[] nextSortedIntArr(int n) {
            int[] arr = new int[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextInt();
            }
            Arrays.sort(arr);
            return arr;
        }

        public long[] nextLongArr(int n) {
            long[] arr = new long[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextLong();
            }
            return arr;
        }

        public char[] nextCharArr(int n) {
            char[] arr = new char[n];
            for (int i = 0; i < n; i++) {
                arr[i] = this.nextChar();
            }
            return arr;
        }
    }

    public static void main(String[] args) {

        InputReader in = new InputReader();
        int N = in.nextInt();

        int input[]=new int[N];
        // int k=in.nextInt();
        HashMap<Integer,Integer> map1=new HashMap<>();

        int flag=-1;

        if(N==0){
            System.out.println(0);
            return;
        }

        for (int i = 0; i < N; i++) {

            input[i]=in.nextInt();
            if(map1.containsKey(input[i])){
                flag=1;
            }else{
                map1.put(input[i],1);
            }
        }

        if(flag==1) {
            System.out.println(2);
            return;
        }

        System.out.println(1);

    }

    static int upperBound(long[] list, long val) {
        int count = list.length - 1, first = 0, it = 0, step = 0;

        while (count > 0) {
            it = first;
            step = count / 2;
            it += step;
            if (!(val < list[it])) {
                first = it + 1;
                it++;
                count -= step + 1;
            } else {
                count = step;
            }
        }
        return first;
    }

}

import java.util.Scanner;

public class Polycorps {

	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = in.nextInt();
		int max = Integer.MIN_VALUE;
		int[] a = new int[101];
		for(int i=0;i<n;i++){
				a[in.nextInt()]++;
				max = a[i]>max ? a[i] : max;
		}
		System.out.println(max);
		in.close();
	}

}

import java.util.*;
public class Polycarps_Pockets {
	public static int max(int[] t) {
		int max=0;
		for(int i=0;i<t.length;i++) {
			if(t[i]>t[max]) {
				max=i;
			}
		}
		return max;
	}

	public static void main(String[] argv) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int[] t = new int[n];
		for(int i=0;i<n;i++) {
			t[i]=sc.nextInt();
		}
		int k =0;
		if(n==1) {
			System.out.print(1);
		}
		else {
			for(int i=0;i<n-1;i++) {
				k=0;
				for(int j=i+1;j<n;j++) {
					if(t[i]==t[j]) {
						k++;
					}
					if(j==n-1) {
						t[i]=k;
					}
				}
			}
			System.out.print(t[max(t)]);

		}
	}
}

import java.io.OutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.List;
import java.util.StringTokenizer;
import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        InputStream inputStream = System.in;
        OutputStream outputStream = System.out;
        InputReader in = new InputReader(inputStream);
        PrintWriter out = new PrintWriter(outputStream);
        A a = new A(in, out);
        out.close();
    }

    public static class A{

        InputReader in ;
        PrintWriter out;

        public A(InputReader in, PrintWriter out) {
            this.in = in;
            this.out = out;
        }

        public void run(){
            int n = in.nextInt();
            List<Integer> coins = new ArrayList<>(n);
            IntStream.range(0,n).forEach( e-> coins.add(0));
            IntStream.range(0,n).forEach( e-> {
                int num = in.nextInt();
                coins.set(num,coins.get(num)+1);
            });

            int answer = IntStream.range(0,n).max().getAsInt();
            out.println(answer);

        }
    }
    static class InputReader {
        public BufferedReader reader;
        public StringTokenizer tokenizer;

        public InputReader(InputStream stream) {
            reader = new BufferedReader(new InputStreamReader(stream), 32768);
            tokenizer = null;
        }

        public String next() {
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                try {
                    tokenizer = new StringTokenizer(reader.readLine());
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
            return tokenizer.nextToken();
        }

        public int nextInt() {
            return Integer.parseInt(next());
        }

    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.HashSet;
import java.util.Set;
import java.util.StringTokenizer;

public class A1003 {
    public static void main(String[] args) {
        InputReader in = new InputReader(System.in);
        int n = in.nextInt();
        int pockets = 1;
        Set<Integer> coins = new HashSet<Integer>();
        for (int i = 0; i < n; i++) {
            int coin = in.nextInt();
            if (coins.contains(coin)) {
                pockets++;
            } else coins.add(coin);
        }
        System.out.println(pockets);
    }
}

class InputReader {
    private BufferedReader reader;
    private StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 32768);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public String readLine() {
        try {
            return reader.readLine();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public char nextChar() {
        return next().charAt(0);
    }
}

import java.io.IOException;
import java.util.Arrays;
import java.util.Scanner;
import java.util.LinkedList;
import java.util.List;

public class Main {

    public static void main(String args[]) {
        Scanner sc = new Scanner(System.in);
        int n;
        n = sc.nextInt();
        int arr[] = new int[n];
        for (int i = 0; i < n; i++)
            arr[i] = sc.nextInt();
        Arrays.sort(arr);
        int count = 1;
        for (int i = 0; i < n - 1; i++) {
            if (arr[i] == arr[i + 1])
                count++;

        }

        System.out.println(count);
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class PolycarpPockets {
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        int n=sc.nextInt();
        int[]a=new int[n];
        int c=0;

        for(int i=0;i<a.length;i++){
            a[i]=sc.nextInt();

        }
        if(a.length==1){
            System.out.println("1");
        }
        else {
            Arrays.sort(a);
            for (int i = 0; i < a.length - 1; i++) {
                if (a[i] == a[i + 1]) {
                    c++;
                }

            }
            System.out.println(c);
        }
    }
}

import java.util.*;

public class Miguel {
    static void process(Scanner ler) {
    }

    public static void main(String[] args) {
        Scanner ler = new Scanner(System.in);
	/*
	int t = ler.nextInt();
	ler.nextLine();
	while (t-- > 0) process(ler);
	*/
	int n = ler.nextInt(), ans = 0;
	int arr[] = new int[200];
	boolean count[] = new boolean[200];

	for (int i = 0; i < n; i++) {
	    arr[i] = ler.nextInt();
	    if (count[arr[i]]) ans++;
	    count[arr[i]] = true;
	}

	if (ans == 0) ans = 1;
	System.out.println(ans);
    }
}

import java.io.*;
import java.util.*;

public class Solution{
    public static void main(String args[]){
        int n;
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        int a[] = new int[n+ 1];
        for(int i = 0;i < n;i++){
            a[i] = sc.nextInt();
        }
        int max = a[0];
        for(int i = 1;i < n;i++){
            if(a[i] > max){
                max = a[i];
            }
        }
        int c[] = new int[max + 1];
        for(int i = 0;i < n;i++){
            c[a[i]]++;
        }
        int max1 = c[1];
        for(int i = 2;i <= max;i++){
            if(c[i] > max){
                max1 = c[i];
            }
        }
        System.out.println(max1);
    }
}

import java.util.Arrays;
import java.util.Scanner;

public class Main {

    public static void main(String[] args) {
    Scanner in = new Scanner(System.in);
    int num = in.nextInt();
    int [] value = new int [num];

    for (int i=0; i<num;i++)
        value[i]= in.nextInt();

        Arrays.sort(value);
        int finall =1;
        int iter =1;
        for (int i=1;i< value.length;i++){
            if(value[i]== value[i-1])
                iter++;
            else {
                if (iter > finall)
                    finall = iter;
                iter = 1;
            }

            }

            System.out.println(finall);

        }

    }

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class v {
    public static void main(String[] args) throws IOException {
        int b = 0;
        int [] ar= new int[101];
       BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
       StringTokenizer tk = new StringTokenizer(in.readLine());
                   String w1 = tk.nextToken();
            int y1 = Integer.parseInt(w1);

       tk = new StringTokenizer(in.readLine());
                    for (int i = 0; i < y1; i++) {
            String w = tk.nextToken();
            int y = Integer.parseInt(w);
            ar[y]++;
        }
                     int o =ar[0];

        for (int i = 1; i < ar.length; i++) {
            if (ar[i]>ar[i-1]) {
                o=ar[i];
            }

        }
        System.out.println(o);
}}

import java.util.Scanner;

public class Main {
    public static void main (String[] args){
        Scanner scanner = new Scanner(System.in);
        int size = scanner.nextInt();
        int arr [] ;
        arr = new int[size];
        for (int i=0; i<size; i++){
            arr[i] = scanner.nextInt();
        }
        int index;
        boolean isSorted =false;
        while (!isSorted){
            isSorted = true;
            for (int j=0; j<size-1;j++){
                if(arr[j]>arr[j+1]){
                    isSorted = false;
                    index = arr [j];
                    arr[j] = arr[j+1];
                    arr [j+1] = index;
                }
            }
        }

        int count=1;
        int max =1;

            for (int i =0;i<size-1;i++){
                if(arr[i]==arr[i+1]){
                   count +=1;
                }else {

                    max = count;
                    count=1;

                }
            }
        if (count!=1){
            max = count;
        }
        System.out.println(max);
        /*for (int i=0; i<size; i++){
            System.out.println(arr[i]);
        }*/

    }
}

import java.io.*;
import java.util.*;

public class Solution {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int x;
        int[] a = new int[101];
        for(int i = 0; i < n; i++) {
            x = sc.nextInt();
            a[x]++;
        }
    /*    for(int i  = 0; i< 10; i++)
            System.out.println(a[i]);*/
        int m = 1;
        for(int i = 0; i < 101;i++) {
            if(a[i] > m) {
                m = a[i];
                       // System.out.println(a[i]);
            }

        }
      //  System.out.println(m);
    }
}

import java.util.HashSet;
import java.util.Scanner;

public class PolycarpsPockets {

	public static void main(String[] args) {
		Scanner scan= new Scanner (System.in);
		int n=scan.nextInt();
		HashSet h=new HashSet();
		for(int i=0;i<n;i++)
		{
			h.add(scan.nextInt());
		}
		System.out.println(h);
		if(h.size()<n)
		{    if(h.size()==1)
			{
				System.out.println(n);
			}
			else
			{
				System.out.println(n-h.size());
			}
		}
		else
		{
			System.out.println(n);
		}
	}

}

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;

public class CodeForces {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int z = scanner.nextInt();
        int[] a = new int[z];
        for(int i=0;i<z;i++) a[i] = scanner.nextInt();
        HashMap<Integer,Integer> map = new HashMap<>();

        for(int x:a) map.put(x,map.getOrDefault(x,0));
        int m = -1, val=0;
        for(Map.Entry k:map.entrySet()){
            if(m>(int)k.getValue()) {
                m = (int) k.getValue();
                val = (int)k.getKey();
            }
        }
        System.out.println(val);
    }
}

	import java.util.*;
	import java.io.*;
	import java.text.*;
	import java.math.*;

	public class Codeforces{
		boolean multipleTC=false;
		void solve( int tc )throws Exception{
			int n=ni(), ans=0, max=0;
			int[]a = new int[105];
			for( int i=0; i<n; i++ ) a[ni()]++;
			for( int i=0; i<n; i++ ) ans=Math.max(a[i], max);
			pn(max);
		}

		void run() throws Exception{
			in = new FastReader();
			out = new PrintWriter( System.out );
			for( int i=1, t=(multipleTC)?ni():1 ; i<=t; i++ )solve(i);
			out.flush();
			out.close();
		}

		public static void main( String[]args )throws Exception{
			new Codeforces().run();
		}

		FastReader in;
		PrintWriter out;

		long[]la( int n )throws Exception{ long[]a=new long[n]; for( int i=0; i<n; i++ )a[i]=nl(); return a; }
		int[]ia( int n )throws Exception{ int[]a=new int[n]; for( int i=0; i<n; i++ )a[i]=ni(); return a; }
		int gcd( int a, int b ){ return (b==0)?a:gcd(b,a%b); }
		void p(Object o){ out.print(o); }
		void pn(Object o){ out.println(o); }
		void pni(Object o){ out.println(o); out.flush(); }
		String n(){ return in.next(); }
		int ni() throws Exception{ return Integer.parseInt(in.next()); }
		long nl() throws Exception{ return Long.parseLong(in.next()); }

		class FastReader{
			BufferedReader br;
			StringTokenizer st;
			public FastReader(){
				br=new BufferedReader(new InputStreamReader(System.in));
			}
			String next(){
				while( st==null || !st.hasMoreElements() ){
					try{
						st = new StringTokenizer( br.readLine() );
					}catch( IOException e ){
						e.printStackTrace();
					}
				}return st.nextToken();
			}
			String nextLine(){
				String str = "";
				try{
					str = br.readLine();
				}catch( IOException e ){
					e.printStackTrace();
				}return str;
			}
		}
	}