#include <iostream>
#include <vector>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>

#define rep(i,n) for(int i = 0; i < (n); ++i)
#define MOOD 1000000007

using namespace std;
using ll = long long;
using P = pair<int,int>;

int cmpnum(const void * n1, const void * n2)
{
    if (*(long long *)n1 < *(long long *)n2)
    {
        return 1;
    }
    else if (*(long long *)n1 > *(long long *)n2)
    {
        return -1;
    }
    else
    {
        return 0;
    }
}

int char_sort_max( const void * a , const void * b ) {
    return strcmp(( char * )a , ( char * )b );
}

int char_sort_min( const void * a , const void * b ) {
    return strcmp(( char * )a , ( char * )b );
}

int gcd(int x, int y)
{
    int t;

    while (y != 0) {
        t = x % y;  x = y;  y = t;
    }
    return x;
}

struct UnionFind{
    vector<int> d;
    UnionFind(int n = 0):d(n,-1){};

    int find(int x){
        if(d[x] < 0) {
            return x;
        }
        else{
            return d[x] = find(d[x]);
        }
    }
    bool unite(int x, int y) {
        x = find(x);
        y = find(y);
        if (x == y) return false;
        if (d[x] > d[y]) swap(x, y);

        d[x] += d[y];
        d[y] = x;
        return true;
    }
    bool same(int x, int y){
        return find(x) == find(y);
    }
    int size(int x){
        return -d[find(x)];
    }

};

struct mint {
    ll x;

    mint(ll x) : x((x % MOOD + MOOD) % MOOD) {}

    mint operator-() const { return mint(-x); }

    mint &operator+=(const mint a) {
        if ((x += a.x) >= MOOD) x -= MOOD;
        return *this;
    }
    mint& operator-=(const mint a) {
        if ((x += MOOD-a.x) >= MOOD) x -= MOOD;
        return *this;
    }

    mint &operator*=(const mint a) {
        if ((x *= a.x) %= MOOD);
        return *this;
    }

    mint operator+(const mint a)const {
        mint res(*this);
        return res += a;
    }

    mint operator-(const mint a) const {
        mint res(*this);
        return res -= a;
    }

    mint operator*(const mint a) const {
        mint res(*this);
        return res *= a;
    }

    mint pow(ll t) const{
        if(!t) return 1;
        mint a = pow(t>>1);
        a *= a;
        if(t&1) a *= *this;
        return a;
    }

    mint inv() const {
        return pow(MOOD-2);
    }

    mint& operator/=(const mint a) {
        return (*this) *= a.inv();
    }

    mint operator/(const mint a) const {
        mint res(*this);
        return res/=a;
    }

};

mint kaijyo(int n) {
    if (n == 0) return 1;
    mint x = kaijyo(n/2);
    x *= x;
    if (n%2 == 1) x *= 2;
    return x;
}

mint choose(int n, int a) {
    mint x = 1, y = 1;
    rep(i,a) {
        x *= n-i;
        y *= i+1;
    }
    return x / y;
}

int main() {
    int N;
    scanf("%d",&N);
    int A[N+1];
    char S[N + 1][11];

    A[N] = 0;

    rep(i,N){
        scanf("%s",S[i]);
        A[i] = 1;
    }

    qsort(S,sizeof(S)/sizeof(S[0])-1,sizeof(S[0]),char_sort_max);

    int max = 1;
    int count = 1;
    rep(i,N){

        if(strcmp(S[i+1],S[i]) == 0){
            A[i+1] = A[i] + 1;
            count++;
        }
        else{
            count = 1;
        }

        if(count > max){
            max = count ;
        }
    }
    rep(i,N) {
        if(max == A[i]){
            printf("%s\n",S[i]);
        }
    }





    return 0;
}

int A(){
    int A,B,C;
    scanf("%d %d %d",&A,&B,&C);
    if(A==B && A !=C){
        printf("Yes");
    }
    else if(A==C && C != B){
        printf("Yes");
    }
    else if(B==C && C != A){
        printf("Yes");
    }
    else{
        printf("No");
    }

    return 0;
}

int B(){
    int N;
    scanf("%d",&N);
    int check;
    int count = 0;

    rep(i,N){
        scanf("%d",&check);
        if(check % 2 == 0){
            if(check % 3 == 0 || check % 5 == 0){}
            else{
                count = -1;
            }
        }
    }

    if(count == -1){
        printf("DENIED");
    }
    else{
        printf("APPROVED");
    }

    return 0;
}



Measured memory_bytes: 5372