One day Vasya decided to have a look at the results of Berland 1910 Football Championship’s finals. Unfortunately he didn't find the overall score of the match; however, he got hold of a profound description of the match's process. On the whole there are n lines in that description each of which described one goal. Every goal was marked with the name of the team that had scored it. Help Vasya, learn the name of the team that won the finals. It is guaranteed that the match did not end in a tie.

Input

The first line contains an integer n (1 ≤ n ≤ 100) — the number of lines in the description. Then follow n lines — for each goal the names of the teams that scored it. The names are non-empty lines consisting of uppercase Latin letters whose lengths do not exceed 10 symbols. It is guaranteed that the match did not end in a tie and the description contains no more than two different teams.

Output

Print the name of the winning team. We remind you that in football the team that scores more goals is considered the winner.

Examples

Input

1
ABC


Output

ABC


Input

5
A
ABA
ABA
A
A


Output

A
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

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

import static java.lang.System.in;
import static java.lang.System.out;

public class Main{
    final static int INF=Integer.MAX_VALUE;
    final static int nINF=Integer.MIN_VALUE;
    final static long MOD=1000000007;
    
    public static void main(String[] args){
        FastReader fr=new FastReader();
        int tc=1;
        while(tc-->0){
            int n=fr.nextInt();
            HashMap<String,Integer>hm=new HashMap<>();
            for(int i=0;i<n;i++){
                String here=fr.nextLine();
                hm.put(here,hm.getOrDefault(here,0)+1);
            }
            int max=nINF;
            for(int here:hm.values()){
                max=max(here,max);
            }

            StringBuilder sb=new StringBuilder();
            for(Map.Entry<String,Integer>me:hm.entrySet()){
                if(me.getValue()==max){
                    sb.append(me.getKey());
                    break;
                }
            }
            out.println(sb);
        }
    }

    ///////////////////////////////////////////////////////////

    static int[] fillInt(int n,FastReader fr){
        int ret[]=new int[n];
        for(int i=0;i<n;i++){
            ret[i]=fr.nextInt();
        }
        return ret;
    }

    static long[] fillLong(int n,FastReader fr){
        long ret[]=new long[n];
        for(int i=0;i<n;i++){
            ret[i]=fr.nextInt();
        }
        return ret;
    }

    static int max(int a,int b){
        return Math.max(a,b);
    }

    static long max(long a,long b){
        return Math.max(a,b);
    }

    static int min(int a,int b){
        return Math.min(a,b);
    }

    static long min(long a,long b){
        return Math.min(a,b);
    }

    static int modDivide(int a,int b){
        return (int) (a*Math.pow(b,MOD-2)%MOD);
    }

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

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

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

    static int longestProperPrefixSuffix(String str){
        // KMP
        int n=str.length();
        int st[]=new int[n];
        int len=0,c=1;
        while(c<n){
            if(str.charAt(len)==str.charAt(c)){
                len++;
                st[c]=len;
                c++;
            }else{
                if(len>0){
                    len=st[len-1];
                }else{
                    st[c]=0;
                    c++;
                }
            }
        }
//        out.println(Arrays.toString(st));
        return st[n-1];
    }

    static int lowerBound(int a[],int val){
        int ret=Arrays.binarySearch(a,val);
        if(ret<0){
            return -1;
        }else{
            while(ret>0 && a[ret-1]==val){
                ret--;
            }
            return ret;
        }
    }

    static int upperBound(int a[],int val){
        int ret=Arrays.binarySearch(a,val);
        if(ret<0){
            return -1;
        }else{
            while(ret<a.length-1 && a[ret+1]==val){
                ret++;
            }
            return ret;
        }
    }

    static class FastReader{
        BufferedReader br;
        StringTokenizer st;

        public FastReader() {
            br = new BufferedReader(new InputStreamReader(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());
        }

        byte nextByte(){
            return Byte.parseByte(next());
        }

        Float nextFloat(){
            return Float.parseFloat(next());
        }

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

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

        short nextShort(){
            return Short.parseShort(next());
        }

        Boolean nextbol(){
            return Boolean.parseBoolean(next());
        }

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