/*#include<deque>
#include<iostream>
#include<fstream>
#define nmax 100006
using namespace std;
int n,X,Y,Z,x[nmax];

deque <pair <int,int> > Dmax,Dmin;

int query1(int j)
{
    while(!Dmax.empty() && Dmax.front().second<j)
        Dmax.pop_front();
    return Dmax.front().first;
}

int query2(int j)
{
    while(!Dmin.empty() && Dmin.front().second<j)
        Dmin.pop_front();
    return Dmin.front().first;
}

void solve()
{
    int i,j=1,ans=0,poz;
    ifstream fin("sir.in");
    ofstream fout("sir.out");
    fin>>n>>X>>Y>>Z;

    for(i=1;i<=n;i++)
    {
        fin>>x[i];
        while(!Dmax.empty() && Dmax.back().first<=x[i])
            Dmax.pop_back();
        Dmax.push_back(make_pair(x[i],i));
        while(!Dmin.empty() && Dmin.back().first>=x[i])
            Dmin.pop_back();
        Dmin.push_back(make_pair(x[i],i));

            while(  (j<=i-Y || query1(j)-query2(j)>Z) && j<=i-X+1 )
                j++;
        //Am demonstrat ca mereu incepem sa cautam de la j-ul solutie stabilit la iteratia anterioara
        if(j<=i-X+1)
            if(i-j+1>=ans)
        {
            ans=i-j+1;
            poz=j;
        }

    }
    fin.close();
    if(ans)
       fout<<ans<<' '<<poz<<' '<<poz+ans-1;
    else
        fout<<-1;
    fin.close();
    fout.close();
}

int main()
{
    solve();
}*/

//Arbori de compresie Huffman
/*#include<iostream>
#include<fstream>
#define nmax 1000005
using namespace std;

struct min_heap{long frec; long poz;};
min_heap H[nmax];

long n,f[nmax],lev[nmax],pos,sol[nmax],inv[nmax];
struct Arb{long e_cod; long frecv;long fin; Arb *st; Arb *dr ;};
Arb *X,*Y,*Z[2*nmax],v;

void insert_heap(long x)
{
    while(x/2 && H[x].frec<H[x/2].frec)
    {
        swap(H[x],H[x/2]);
        //pos=H[x].poz;
        x=x/2;

    }

}

void delete_em(long x)
{
    int y=-2;
    //fiind mai mic decat restul valorilor din heap
    while(x!=y)
    {
        y=x;
        if(2*x<=n && H[x].frec>H[2*x].frec)
            x=2*y;
        if(2*y+1<=n && H[x].frec>H[2*y+1].frec)
            x=2*y+1;
        if(x!=y)
            swap(H[x],H[y]);
    }

}

void read()
{
    ifstream fin("huffman.in");
    fin>>n;
    for(long i=1;i<=n;i++)
       {
           fin>>H[i].frec;
           H[i].poz=i;
           f[i]=H[i].frec;
           inv[f[i]]=i;
           insert_heap(i);
           Z[i]=new Arb;
           Z[i]->e_cod=1;
           Z[i]->dr=NULL;
           Z[i]->st=NULL;
           Z[i]->frecv=f[i];
           Z[i]->fin=i;
       }
    fin.close();

}

long ras;

void dfs(Arb * x)
{
    if(x->e_cod==0)
       {ras+=x->frecv;
       dfs(x->st);
       dfs(x->dr);
       }
       else
        return;

}
long ans;

void dfs2(Arb *x, long nod,long nivel)
{
    if(x->e_cod==0)
    {
        dfs2(x->st,2*nod,nivel+1);
        dfs2(x->dr,2*nod+1,nivel+1);
    }
    else
    {sol[x->fin]=nod;
    lev[x->fin]=nivel;
    ans+=(x->frecv)*nivel;
    }

}

void solve()
{
    long i=0,m=n;
    min_heap x,y;
    while(n>1)
    {
        i++;
        //cout<<H[2].frec<<' ';
        x=H[1];
        //cout<<x.frec<<' ';
        if(x.poz>=m)
            X=Z[x.poz];
        else
        {
            X=new Arb;
            X->frecv=x.frec;
            X->st=NULL;
            X->dr=NULL;
            X->e_cod=1;
            X->fin=x.poz;
        }
        //cout<<x.poz<<' ';
        H[1]=H[n--];
        delete_em(1);
        y=H[1];
        //cout<<y.frec<<' ';
        //cout<<y.poz<<'\n';
        if(y.poz>=m)
           Y=Z[y.poz];
        else
        {
            Y=new Arb;
            Y->frecv=y.frec;
            Y->st=NULL;
            Y->dr=NULL;
            Y->e_cod=1;
            Y->fin=y.poz;

        }
        H[1]=H[n--];
        delete_em(1);
        H[++n].frec=x.frec+y.frec;
        //cout<<H[n].frec<<' ';
        pos=m+i;
        H[n].poz=pos;
        insert_heap(n);
        //cout<<pos<<' ';
        Z[pos]=new Arb;
        Z[pos]->e_cod=0;
        Z[pos]->st=X;
        Z[pos]->dr=Y;
        Z[pos]->frecv=X->frecv+Y->frecv;
        //cout<<pos<<' ';
        //cout<<x<<' '<<y<<'\n';

    }
    //verificare
    ofstream fout("huffman.out");
    //cout<<dfs(Z[pos],0)<<'\n';
    //fout<<dfs(Z[pos],0)<<'\n';
    dfs(Z[pos]);
    cout<<-ras;
    dfs2(Z[pos],0,0);
    fout<<ans<<'\n';
    for(i=1;i<=m;i++)
        fout<<lev[i]<<' '<<sol[i]<<'\n';
    fout.close();

}


int main()
{
    read();
    //for(int i=1;i<=n;i++)
      //  cout<<H[i]<<' ';
      solve();
}
*/
//Elementul majoritar-Alg lui Moore, dem prin Inductie
//Indiferent de caz, raman 2 intervale pe care se aplica ip de inductie si modul de constructie al alg cu primul element selectat de candidat
#include<iostream>
#include<fstream>
#define nmax 1000005
using namespace std;
int n,v[nmax];
int main()
{
    int i,ans,ap=0;
    ifstream fin("elmaj.in");
    ofstream fout("elmaj.out");
    fin>>n;
    for(i=1;i<=n;i++)
        fin>>v[i];
        fin.close();
        for(i=1;i<=n;i++)
        {
            if(!ap)
            {
                ans=v[i];
                ap=1;
            }
            else
                if(v[i]==ans)
                ap++;
            else
                ap--;
        }
        ap=0;
        for(i=1;i<=n;i++)
            if(v[i]==ans)
                ap++;
            if(ap>=n/2+1)
                fout<<ans<<' '<<ap;
            else fout<<-1;
}