import java.util.*;
public class PolycarpsPockets {
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int n = in.nextInt();
        int[] freq = new int[101];
        int ans = -1;
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            freq[x]++;
            ans = Math.max(ans, freq[x]);
        }
        System.out.println(ans);
    }
}

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

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.*;

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

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

/*	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]);
		}
	}

// #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;
    }
}

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

//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;
    }

}

/* 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);
	}
}

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

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

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

//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.*;
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.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.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);

    }
}

//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;

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

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

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

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.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.*;
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();
        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[]){
        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 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 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 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.*;
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.*;

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

}

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

/* 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();
	}
}

// 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.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.*;
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.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.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.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;
			}
		}
	}