// iGraph.cpp : Defines the entry point for the console application.
//

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>

using namespace std;

class Graph
{
public:
    int size;
    int **Array;
    int *visited;
    int *curDist;
    int *toBeChecked;
    int *predessor;

    Graph()
    {
        size = 0;
        Array = NULL;
        visited = 0;
        curDist = 0;
        toBeChecked = 0;
        predessor = 0;
    }

    Graph(int s)
    {
        size = s;

        Array = new int*[size];
        for (int i = 0; i < size; i++)
        {
            Array[i] = new int[size];
        }
        visited = new int[size];
        curDist = new int[size];
        toBeChecked = new int[size];
        predessor = new int[size];

        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                Array[i][j] = 0;

        for (int i = 0; i < size; i++)
        {
            visited[i] = 0;
        }
    }

    void AddEdge(int start, int end, int value = 1)
    {
        Array[start][end] = value;

    }

    void removeEdge(int start, int end)
    {
        Array[start][end] = 0;
    }

    void print()
    {
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < size; j++)
            {
                cout << Array[i][j] <<" ";
            }
            cout << endl;
        }
        cout << "------------------" << endl;
    }

};

int main()
{

    set<int> s[100000];

    set<int>::iterator it;
    int n, m;
    int i, j;

    int  color;
    map<int, int> col;

    //bool vis[10000];
    map<int,bool> v;

    int maxx = -1;

    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        cin >> color;
        col[i] = color;
        v[col[i]] = true;
    }

    for (int k = 1; k <= m; k++)
    {
        cin >> i >> j;
        if (col[i] != col[j])
        {
            s[col[i]].insert(col[j]);
            s[col[j]].insert(col[i]);
        }

    }

    for (auto x :v) {
        if (x.second==true)
        {
            if ((int)s[x.first].size() > maxx)
            {

                maxx = s[x.first].size();
            }

        }

    }

        for (int i = 1; i <= 100000; i++)
        {
                     if ((s[i].size() == maxx )&& (v[i]==true))
                     {
                            maxx = i;
                            break;
                     }
        }

    cout << maxx << endl;

    return 0;
}


// iGraph.cpp : Defines the entry point for the console application.
//

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>

using namespace std;

class Graph
{
public:
    int size;
    int **Array;
    int *visited;
    int *curDist;
    int *toBeChecked;
    int *predessor;

    Graph()
    {
        size = 0;
        Array = NULL;
        visited = 0;
        curDist = 0;
        toBeChecked = 0;
        predessor = 0;
    }

    Graph(int s)
    {
        size = s;

        Array = new int*[size];
        for (int i = 0; i < size; i++)
        {
            Array[i] = new int[size];
        }
        visited = new int[size];
        curDist = new int[size];
        toBeChecked = new int[size];
        predessor = new int[size];

        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                Array[i][j] = 0;

        for (int i = 0; i < size; i++)
        {
            visited[i] = 0;
        }
    }

    void AddEdge(int start, int end, int value = 1)
    {
        Array[start][end] = value;

    }

    void removeEdge(int start, int end)
    {
        Array[start][end] = 0;
    }

    void print()
    {
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < size; j++)
            {
                cout << Array[i][j] <<" ";
            }
            cout << endl;
        }
        cout << "------------------" << endl;
    }

};

int main()
{

    set<int> s[100000];

    set<int>::iterator it;
    int n, m;
    int i, j;

    int  color;
    map<int, int> col;

    //bool vis[10000];
    map<int,bool> v;

    int maxx = -1;

    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        cin >> color;
        col[i] = color;
        v[col[i]] = true;
    }

    for (int k = 1; k <= m; k++)
    {
        cin >> i >> j;
        if (col[i] != col[j])
        {
            s[col[i]].insert(col[j]);
            s[col[j]].insert(col[i]);
        }

    }

    for (auto x :v) {
        if (x.second==true)
        {
            if ((int)s[x.first].size() > maxx && i != 100000)
            {

                maxx = s[x.first].size();
            }

        }

    }

        for (int i = 1; i <= 100000; i++)
        {
                     if ((s[i].size() == maxx )&& (v[i]==true))
                     {
                            maxx = i;
                            break;
                     }
        }

    cout << maxx << endl;

    return 0;
}


// iGraph.cpp : Defines the entry point for the console application.
//

#include <iostream>
#include <queue>
#include <vector>
#include <set>
#include <map>

using namespace std;

class Graph
{
public:
    int size;
    int **Array;
    int *visited;
    int *curDist;
    int *toBeChecked;
    int *predessor;

    Graph()
    {
        size = 0;
        Array = NULL;
        visited = 0;
        curDist = 0;
        toBeChecked = 0;
        predessor = 0;
    }

    Graph(int s)
    {
        size = s;

        Array = new int*[size];
        for (int i = 0; i < size; i++)
        {
            Array[i] = new int[size];
        }
        visited = new int[size];
        curDist = new int[size];
        toBeChecked = new int[size];
        predessor = new int[size];

        for (int i = 0; i < size; i++)
            for (int j = 0; j < size; j++)
                Array[i][j] = 0;

        for (int i = 0; i < size; i++)
        {
            visited[i] = 0;
        }
    }

    void AddEdge(int start, int end, int value = 1)
    {
        Array[start][end] = value;

    }

    void removeEdge(int start, int end)
    {
        Array[start][end] = 0;
    }

    void print()
    {
        for (int i = 0; i < size; i++)
        {
            for (int j = 0; j < size; j++)
            {
                cout << Array[i][j] <<" ";
            }
            cout << endl;
        }
        cout << "------------------" << endl;
    }

};

int main()
{

    //set<int> s[100000];
    map<int, set<int>> sett;

    set<int>::iterator it;
    int n, m;
    int i, j;

    int  color;
    map<int, int> col;

    //bool vis[10000];
    map<int,bool> v;

    int maxx = -1;

    cin >> n >> m;
    for (int i = 1; i <= n; i++)
    {
        cin >> color;
        col[i] = color;
        v[col[i]] = true;
    }

    for (int k = 1; k <= m; k++)
    {
        cin >> i >> j;
        if (col[i] != col[j])
        {
            sett[col[i]].insert(col[j]);
            sett[col[j]].insert(col[i]);
        }

    }

    for (auto x :v) {
        if (x.second==true)
        {
            if ((int)sett[x.first].size() > maxx )
            {

                maxx = sett[x.first].size();
            }

        }

    }

    for (auto x : v) {

                     if ((sett[x.first].size() == maxx )&& (v[x.first]==true))
                     {
                         maxx = x.first;
                            break;
                     }
        }

    cout << maxx << endl;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

int main()
{
    int i,n,m,a,b;
    cin>>n>>m;

    vector<int> A(n+1);

    int minc=0;
    for(i=1;i<=n;++i)
    {
            cin>>A[i];
            minc=max(minc,A[i]);
    }

    vector<set<int> > S(minc+1);

    for(i=0;i<m;++i)
    {
        cin>>a>>b;
        if(A[a]!=A[b])
        {
            S[A[a]].insert(A[b]);
            S[A[b]].insert(A[a]);
        }
    }

    int ans=0,pos;

    for(i=1;i<=minc;++i)
    {
        if(S[i].size()>ans)
        {
            pos=i;
            ans=S[i].size();
        }
    }
    cout<<pos<<endl;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

int main()
{
    int i,n,m,a,b;
    cin>>n>>m;

    vector<int> A(n+1);

    int minc=0,_mn=1<<30;
    for(i=1;i<=n;++i)
    {
            cin>>A[i];
            minc=max(minc,A[i]);
            _mn=min(_mn,A[i]);
    }

    vector<set<int> > S(minc+1);

    for(i=0;i<m;++i)
    {
        cin>>a>>b;
        if(A[a]!=A[b])
        {
            S[A[a]].insert(A[b]);
            S[A[b]].insert(A[a]);
        }
    }

    int ans=0,pos=_mn;

    for(i=1;i<=minc;++i)
    {
        if(S[i].size()>ans)
        {
            pos=i;
            ans=S[i].size();
        }
    }
    cout<<pos<<endl;

    return 0;
}


#include<bits/stdc++.h>

using namespace std;

int main()
{
    int i,n,m,a,b;
    cin>>n>>m;

    vector<int> A(n);

    for(i=0;i<n;cin>>A[i],++i);

    vector<set<int> > S(100001);

    for(i=0;i<m;++i)
    {
        cin>>a>>b;
        if(A[a]!=A[b])
        {
            S[A[a]].insert(A[b]);
            S[A[b]].insert(A[a]);
        }
    }
    int ans=0;
    for(i=1;i<=100000;++i)
    {
        if(S[i].size()>ans)
        {
           // pos=i;
            ans=S[i].size();
        }
    }
    cout<<ans-1<<endl;

    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

int n, m, z=100001;
int a[100100];
set<int> v[100100];

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]),z=min(z,--a[i]);
    for (int i = 0; i < m; i++){
        int x, y;
        scanf("%d%d", &x, &y);
        if (a[x - 1] != a[y - 1]){
            v[a[x - 1]].insert(a[y - 1]);
            v[a[y - 1]].insert(a[x - 1]);
        }
    }
    for (int i = 0; i < 100001; i++)
        if (v[i].size()>v[z].size())
            z = i;
    printf("%d", z+1);
    return 0;
}


#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>

using namespace std;

int n, m, z=1000001;
int a[100100];
set<int> v[100100];

int main() {
    scanf("%d%d", &n, &m);
    for (int i = 0; i < n; i++) scanf("%d", &a[i]),z=min(z,a[i]-1);
    for (int i = 0; i < m; i++){
        int x, y;
        scanf("%d%d", &x, &y);
        v[a[x-1]].insert(a[y-1]);
        v[a[y-1]].insert(a[x-1]);
    }
    for (int i = 0; i < 100001; i++)
        if (v[i].size()>v[z].size())
            z = i;
    printf("%d", z);
    return 0;
}


#include <algorithm>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>

using namespace std;

const int N = 1e5+5;

typedef vector<int> VI;

VI g[N], rc[N];
int n, m, c[N];

int main()
{
  scanf("%d%d", &n, &m);
  for (int i = 0; i < n; i++) {
    scanf("%d", c+i);
    rc[c[i]].push_back(i);
  }
  for (int i = 0; i < m; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    a--;
    b--;
    g[a].push_back(b);
    g[b].push_back(a);
  }
  int maxc = -1, maxv = -1;
  for (int i = 0; i < N; i++) {
    if (rc[i].size() == 0)
      continue;
    set<int> cs;
    for (auto u: rc[i])
      for (auto v: g[u])
        if (c[u] != c[v])
          cs.insert(c[v]);
    if (maxc == -1 || maxv < cs.size()) {
      maxc = i;
      maxv = cs.size();
    }
  }
  printf("%d\n", maxc);
  return 0;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual,igual2,tamano_max;
	scanf("%d",&n);
	scanf("%d",&m);
	tamano_max=100000;
	vertice*vertices[tamano_max];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[c]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			vertices[color_aux[origen-1]]->cantidad +=agregar_enlace(&(vertices[color_aux[origen-1]])->sig_enlace,color_aux[destino-1]);
			vertices[color_aux[destino-1]]->cantidad += agregar_enlace(&(vertices[color_aux[destino-1]])->sig_enlace,color_aux[origen-1]);
		}
	}
	mayor=vertices[color_aux[0]]->cantidad;
	pos=color_aux[0];
	for(conteo1=1;conteo1<n;conteo1++)
	{
		if(vertices[color_aux[conteo1]]->cantidad>=mayor)
		{
			if(vertices[color_aux[conteo1]]->cantidad==mayor)
			{
				if(vertices[color_aux[conteo1]]->color_vertice<vertices[pos]->color_vertice)
				{
					mayor=vertices[color_aux[conteo1]]->cantidad;
					pos=color_aux[conteo1];
				}
			}
			else
			{
				mayor=vertices[color_aux[conteo1]]->cantidad;
				pos=color_aux[conteo1];
			}
		}
	}

	printf("%d",vertices[pos]->color_vertice);

	return 0;
}
int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void recorrer(enlace*);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[conteo1]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			igual=0;
			for(conteo2=0;conteo2<n&&!igual;conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[origen-1])
				{
					vertices[conteo2]->cantidad +=agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[destino-1]);
					igual=1;
				}
			}
			igual=0;
			for(conteo2=0;conteo2<n&&!igual;conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[destino-1])
				{
					vertices[conteo2]->cantidad += agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[origen-1]);
					igual=1;
				}
			}
		}
	}

	for(conteo1=0;conteo1<n;conteo1++)
	{
		if(vertices[conteo1]->cantidad!=-1)
		{
			for(conteo2=1+conteo1;conteo2<n;conteo2++)
			{
				if(vertices[conteo2]->cantidad!=-1)
				{
					if(color_aux[conteo1]==color_aux[conteo2])
					{
						vertices[conteo1]->cantidad+=vertices[conteo2]->cantidad;
						vertices[conteo2]->cantidad=-1;
					}

				}
			}
			if(conteo1>0)
			{
				if(vertices[conteo1]->cantidad>=mayor)
				{
					if(vertices[conteo1]->cantidad==mayor)
					{
						if(color_aux[conteo1]<color_aux[pos])
						{
							mayor=vertices[conteo1]->cantidad;
							pos=conteo1;
						}
					}
					else
					{
						mayor=vertices[conteo1]->cantidad;
						pos=conteo1;
					}
				}
			}
			else
			{
				mayor=vertices[conteo1]->cantidad;
				pos=conteo1;
			}
		}
	}

	printf("%d",color_aux[pos]);

	return 0;
}
int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(void);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void recorrer(enlace*);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
	}
	for(conteo1=0;conteo1<n;conteo1++)
	{
		vertices[conteo1]=crear_vertice();
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			vertices[origen-1]->cantidad +=agregar_enlace(&(vertices[origen-1])->sig_enlace,color_aux[destino-1]);
			vertices[destino-1]->cantidad += agregar_enlace(&(vertices[destino-1])->sig_enlace,color_aux[origen-1]);
		}
	}

	for(conteo1=0;conteo1<n;conteo1++)
	{
		if(vertices[conteo1]->cantidad!=-1)
		{
			for(conteo2=1+conteo1;conteo2<n;conteo2++)
			{
				if(vertices[conteo2]->cantidad!=-1)
				{
					if(color_aux[conteo1]==color_aux[conteo2])
					{
						vertices[conteo1]->cantidad+=vertices[conteo2]->cantidad;
						vertices[conteo2]->cantidad=-1;
					}

				}
			}
			if(conteo1>0)
			{
				if(vertices[conteo1]->cantidad>=mayor)
				{
					if(vertices[conteo1]->cantidad==mayor)
					{
						if(color_aux[conteo1]<color_aux[pos])
						{
							mayor=vertices[conteo1]->cantidad;
							pos=conteo1;
						}
					}
					else
					{
						mayor=vertices[conteo1]->cantidad;
						pos=conteo1;
					}
				}
			}
			else
			{
				mayor=vertices[conteo1]->cantidad;
				pos=conteo1;
			}
		}
	}

	printf("%d",color_aux[pos]);

	return 0;
}
int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(void)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int cantidad_enlace , numero_vertice , color_vertice;
	struct VERTICE*sig_enlace;
}enlace;
enlace*crear_enlace(int,int);
int main()
{
	int n,m,conteo1,destino,origen,c,cantidad,color,pos;
	scanf("%d",&n);
	scanf("%d",&m);
	enlace*vertices[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		vertices[conteo1]=crear_enlace(conteo1+1,c);
	}
	for(conteo1=1;conteo1<=m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		vertices[origen-1]->cantidad_enlace+=1;
		vertices[destino-1]->cantidad_enlace+=1;
	}
	cantidad=n-vertices[0]->cantidad_enlace-1;
	color=vertices[0]->color_vertice;
	pos=0;
	for(conteo1=1;conteo1<n;conteo1++)
	{
		if(n-vertices[conteo1]->cantidad_enlace-1<=cantidad&&n-vertices[conteo1]->cantidad_enlace-1!=0)
		{
			if(n-vertices[conteo1]->cantidad_enlace-1==cantidad)
			{
				if(vertices[conteo1]->color_vertice<color)
				{
					pos=conteo1;
					cantidad=n-vertices[conteo1]->cantidad_enlace-1;
					color=vertices[conteo1]->color_vertice;
				}
			}
			else
			{
				pos=conteo1;
				cantidad=n-vertices[conteo1]->cantidad_enlace-1;
				color=vertices[conteo1]->color_vertice;
			}
		}
		if(n-vertices[conteo1]->cantidad_enlace-1==0)
		{
			if(vertices[conteo1]->color_vertice<color)
			{
				pos=conteo1;
				cantidad=n-vertices[conteo1]->cantidad_enlace-1;
				color=vertices[conteo1]->color_vertice;
			}
		}
		if(vertices[conteo1]->cantidad_enlace==0)
		{
			if(vertices[conteo1]->color_vertice<color)
			{
				pos=conteo1;
				cantidad=n-vertices[conteo1]->cantidad_enlace-1;
				color=vertices[conteo1]->color_vertice;
			}
		}
	}
	printf("%d",vertices[pos]->color_vertice);
	return 0;
}
enlace*crear_enlace(int x,int c)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->cantidad_enlace=0;
	nuevo->numero_vertice=x;
	nuevo->color_vertice=c;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct VERTICE
{
	int color_vertice,cantidad_vecino;
	struct VERTICE*sig_vertice;
	struct VECINO*sig_vecino;
}vertice;
typedef struct VECINO
{
	int color_vecino;
	struct VECINO*next;
}vecino;
vecino*crear_vecino(int);
vertice*crear_vertice(int);
void agregar_vecino(vertice**,int,int);
void agregar_vertice(vertice**,int);
void recorrer_insertar(vecino**cabeza,int);
int recorrer_verificar(vecino*);
void verificar_vecino(vertice**);
void respuesta(vertice*,int*,int*);
int main()
{
	vertice*cabeza=NULL;
	int n,m,conteo1,destino,origen,c,mayor,color_respuesta;
	int color_aux[n];
	scanf("%d",&n);
	scanf("%d",&m);
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		agregar_vertice(&cabeza,c);
		color_aux[conteo1]=c;
	}

	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			agregar_vecino(&cabeza,color_aux[origen-1],color_aux[destino-1]);
			agregar_vecino(&cabeza,color_aux[destino-1],color_aux[origen-1]);
		}
	}
	verificar_vecino(&cabeza);
	mayor=cabeza->cantidad_vecino;
	color_respuesta=cabeza->color_vertice;
	respuesta(cabeza,&color_respuesta,&mayor);
	printf("%d ",color_respuesta);

	return 0;
}
void respuesta(vertice*cabeza,int*co,int*ma)
{
	if(cabeza)
	{
		if(cabeza->cantidad_vecino>=*ma)
		{
			if(cabeza->cantidad_vecino==*ma)
			{
				if(cabeza->color_vertice<*co)
				{
					*co=cabeza->color_vertice;
					*ma=cabeza->cantidad_vecino;
				}
			}
			else
			{
				*co=cabeza->color_vertice;
				*ma=cabeza->cantidad_vecino;
			}
		}
		respuesta(cabeza->sig_vertice,co,ma);
	}
}
void verificar_vecino(vertice**cabeza)
{
	if(*cabeza)
	{
		int valor;
		(*cabeza)->cantidad_vecino=recorrer_verificar((*cabeza)->sig_vecino);
		verificar_vecino(&(*cabeza)->sig_vertice);
	}
}
int recorrer_verificar(vecino*cabeza)
{
	int valor=0;
	if(cabeza)
	{
		valor=recorrer_verificar(cabeza->next)+1;
	}

	return valor;
}
void recorrer_insertar(vecino**cabeza,int des)
{
	if(!*cabeza)
	{
		*cabeza=crear_vecino(des);
	}
	else
	{
		if((*cabeza)->color_vecino!=des)
		{
			recorrer_insertar(&(*cabeza)->next,des);
		}
	}
}
void agregar_vecino(vertice**cabeza,int or,int des)
{
	if(*cabeza)
	{
		if((*cabeza)->color_vertice==or)
		{
			recorrer_insertar(&(*cabeza)->sig_vecino,des);
		}
		else
		{
			agregar_vecino(&(*cabeza)->sig_vertice,or,des);
		}
	}
}
void agregar_vertice(vertice**cabeza,int colo)
{
	if(!*cabeza)
	{
		*cabeza=crear_vertice(colo);
	}
	else
	{
		if((*cabeza)->color_vertice!=colo)
		{
			agregar_vertice(&(*cabeza)->sig_vertice,colo);
		}
	}
}
vertice*crear_vertice(int colo)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_vertice=NULL;
	nuevo->sig_vecino=NULL;
	nuevo->color_vertice=colo;
	nuevo->cantidad_vecino=0;
	return nuevo;
}
vecino*crear_vecino(int colo)
{
	vecino*nuevo=(vecino*)malloc(sizeof(vecino));
	nuevo->next=NULL;
	nuevo->color_vecino=colo;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct VERTICE
{
	int color_vertice,cantidad_vecino;
	struct VERTICE*sig_vertice;
	struct VECINO*sig_vecino;
}vertice;
typedef struct VECINO
{
	int color_vecino;
	struct VECINO*next;
}vecino;
vecino*crear_vecino(int);
vertice*crear_vertice(int);
void agregar_vecino(vertice**,int,int);
void agregar_vertice(vertice**,int);
void recorrer_insertar(vecino**cabeza,int,int*);
void respuesta(vertice*,int*,int*);
int main()
{
	vertice*cabeza=NULL;
	int n,m,conteo1,destino,origen,c,mayor,color_respuesta;
	int color_aux[n];
	scanf("%d",&n);
	scanf("%d",&m);
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		agregar_vertice(&cabeza,c);
		color_aux[conteo1]=c;
	}

	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			agregar_vecino(&cabeza,color_aux[origen-1],color_aux[destino-1]);
			agregar_vecino(&cabeza,color_aux[destino-1],color_aux[origen-1]);
		}
	}
	mayor=cabeza->cantidad_vecino;
	color_respuesta = cabeza->color_vertice;

	respuesta(cabeza,&color_respuesta,&mayor);
	printf("%d ",color_respuesta);

	return 0;
}
void respuesta(vertice*cabeza,int*co,int*ma)
{
	if(cabeza)
	{
		if(cabeza->cantidad_vecino>=*ma)
		{
			if(cabeza->cantidad_vecino==*ma)
			{
				if(cabeza->color_vertice<*co)
				{
					*co=cabeza->color_vertice;
					*ma=cabeza->cantidad_vecino;
				}
			}
			else
			{
				*co=cabeza->color_vertice;
				*ma=cabeza->cantidad_vecino;
			}
		}
		respuesta(cabeza->sig_vertice,co,ma);
	}
}
void recorrer_insertar(vecino**cabeza,int des,int*valor)
{
	if(!*cabeza)
	{
		*cabeza=crear_vecino(des);
		*valor=1;
	}
	else
	{
		if((*cabeza)->color_vecino!=des)
		{
			recorrer_insertar(&(*cabeza)->next,des,valor);
		}
	}
}
void agregar_vecino(vertice**cabeza,int or,int des)
{
	if(*cabeza)
	{
		if((*cabeza)->color_vertice==or)
		{
			int valor=0;
			recorrer_insertar(&(*cabeza)->sig_vecino,des,&valor);
			(*cabeza)->cantidad_vecino+=valor;
		}
		else
		{
			agregar_vecino(&(*cabeza)->sig_vertice,or,des);
		}
	}
}
void agregar_vertice(vertice**cabeza,int colo)
{
	if(!*cabeza)
	{
		*cabeza=crear_vertice(colo);
	}
	else
	{
		if((*cabeza)->color_vertice!=colo)
		{
			agregar_vertice(&(*cabeza)->sig_vertice,colo);
		}
	}
}
vertice*crear_vertice(int colo)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_vertice=NULL;
	nuevo->sig_vecino=NULL;
	nuevo->color_vertice=colo;
	nuevo->cantidad_vecino=0;
	return nuevo;
}
vecino*crear_vecino(int colo)
{
	vecino*nuevo=(vecino*)malloc(sizeof(vecino));
	nuevo->next=NULL;
	nuevo->color_vecino=colo;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void recorrer(enlace*);
void quickshort(int tamano,vertice*v[tamano],int primero,int ultimo);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual,igual2;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[conteo1]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			igual=igual2=0;
			for(conteo2=0;conteo2<n&&(igual==0||igual2==0);conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[origen-1]&&igual==0)
				{
					vertices[conteo2]->cantidad +=agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[destino-1]);
					igual=1;
				}
				if(vertices[conteo2]->color_vertice==color_aux[destino-1]&&igual2==0)
				{
					vertices[conteo2]->cantidad += agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[origen-1]);
					igual2=1;
				}
			}
		}
	}
	quickshort(n,vertices,0,n-1);
	mayor=vertices[n-1]->cantidad;
	pos=n-1;
	for(conteo1=n-2;conteo1>=0;conteo1--)
	{
		if(vertices[conteo1]->cantidad==mayor)
		{
			if(vertices[conteo1]->cantidad<vertices[pos]->color_vertice)
			{
				pos=conteo1;
			}
		}
		else
		{
			break;
		}
	}

	printf("%d",vertices[pos]->color_vertice);

	return 0;
}
void quickshort(int tamano,vertice*v[tamano],int primero,int ultimo)
{
	int central,i,j,pivote;
	i=primero;
	j=ultimo;
	central=(primero+ultimo)/2;
	pivote=v[central]->cantidad;
	do
	{
		while(v[i]->cantidad<pivote)i++;
		while(v[j]->cantidad>pivote)j--;
		if(i<=j)
		{
			struct ENLACE*aux_enlace=v[i]->sig_enlace;
						v[i]->sig_enlace=v[j]->sig_enlace;
						v[j]->sig_enlace=aux_enlace;
			int aux=v[i]->cantidad;
				v[i]->cantidad=v[j]->cantidad;
				v[j]->cantidad=aux;

			 	aux=v[i]->color_vertice;
				v[i]->color_vertice=v[j]->color_vertice;
				v[j]->color_vertice=aux;
			i++;
			j--;
		}
	}while(i<=j);
	if(primero<j)
	{
		quickshort(tamano,v,primero,j);
	}
	if(i<ultimo)
	{
		quickshort(tamano,v,i,ultimo);
	}
}

int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void recorrer(enlace*);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual,igual2;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[conteo1]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			igual=igual2=0;
			for(conteo2=0;conteo2<n&&(igual==0||igual2==0);conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[origen-1]&&igual==0)
				{
					vertices[conteo2]->cantidad +=agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[destino-1]);
					igual=1;
				}
				if(vertices[conteo2]->color_vertice==color_aux[destino-1]&&igual2==0)
				{
					vertices[conteo2]->cantidad += agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[origen-1]);
					igual2=1;
				}
			}
		}
	}

	for(conteo1=0;conteo1<n;conteo1++)
	{
		if(vertices[conteo1]->cantidad!=0)
		{
			for(conteo2=1+conteo1;conteo2<n;conteo2++)
			{
				if(vertices[conteo2]->cantidad!=0)
				{
					if(color_aux[conteo1]==color_aux[conteo2])
					{
						vertices[conteo1]->cantidad+=vertices[conteo2]->cantidad;
						vertices[conteo2]->cantidad=-1;
					}

				}
			}
			if(conteo1>0)
			{
				if(vertices[conteo1]->cantidad>=mayor)
				{
					if(vertices[conteo1]->cantidad==mayor)
					{
						if(color_aux[conteo1]<color_aux[pos])
						{
							mayor=vertices[conteo1]->cantidad;
							pos=conteo1;
						}
					}
					else
					{
						mayor=vertices[conteo1]->cantidad;
						pos=conteo1;
					}
				}
			}
			else
			{
				mayor=vertices[conteo1]->cantidad;
				pos=conteo1;
			}
		}
	}

	printf("%d",color_aux[pos]);

	return 0;
}
int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void recorrer(enlace*);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual,igual2;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[conteo1]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			igual=igual2=0;
			for(conteo2=0;conteo2<n&&(igual==0||igual2==0);conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[origen-1]&&igual==0)
				{
					vertices[conteo2]->cantidad +=agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[destino-1]);
					igual=1;
				}
				if(vertices[conteo2]->color_vertice==color_aux[destino-1]&&igual2==0)
				{
					vertices[conteo2]->cantidad += agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[origen-1]);
					igual2=1;
				}
			}
		}
	}

	mayor=vertices[0]->cantidad;
	pos=0;
	for(conteo1=0;conteo1<n;conteo1++)
	{
		if(vertices[conteo1]->cantidad>=mayor)
		{
			if(vertices[conteo1]->cantidad==mayor)
			{
				if(color_aux[conteo1]<color_aux[pos])
				{
					mayor=vertices[conteo1]->cantidad;
					pos=conteo1;
				}
			}
			else
			{
				mayor=vertices[conteo1]->cantidad;
				pos=conteo1;
			}
		}
	}

	printf("%d",color_aux[pos]);

	return 0;
}
int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void ordenar(int tamano,vertice*v[tamano],int primero,int ultimo);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual,igual2;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[conteo1]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			igual=igual2=0;
			for(conteo2=0;conteo2<n&&(igual==0||igual2==0);conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[origen-1]&&igual==0)
				{
					vertices[conteo2]->cantidad +=agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[destino-1]);
					igual=1;
				}
				if(vertices[conteo2]->color_vertice==color_aux[destino-1]&&igual2==0)
				{
					vertices[conteo2]->cantidad += agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[origen-1]);
					igual2=1;
				}
			}
		}
	}

	ordenar(n,vertices,0,n-1);

	mayor=vertices[n-1]->cantidad;
	pos=n-1;
	for(conteo1=n-2;conteo1>=0;conteo1--)
	{
		if(vertices[conteo1]->cantidad==mayor)
		{
			if(vertices[conteo1]->color_vertice < vertices[pos]->color_vertice)
			{
				pos=conteo1;
			}
		}
		else
		{
			break;
		}
	}
	printf("%d",vertices[pos]->color_vertice);

	return 0;
}
void ordenar(int tamano,vertice*v[tamano],int primero,int ultimo)
{
	int central,i,j,pivote;
	i=primero;
	j=ultimo;
	central=(primero+ultimo)/2;
	pivote=v[central]->cantidad;
	do
	{
		while(v[i]->cantidad<pivote)i++;
		while(v[j]->cantidad>pivote)j--;
		if(i<=j)
		{
			struct ENLACE*aux_enlace=v[i]->sig_enlace;
						v[i]->sig_enlace=v[j]->sig_enlace;
						v[j]->sig_enlace=aux_enlace;
			int aux=v[i]->cantidad;
				v[i]->cantidad=v[j]->cantidad;
				v[j]->cantidad=aux;

			 	aux=v[i]->color_vertice;
				v[i]->color_vertice=v[j]->color_vertice;
				v[j]->color_vertice=aux;
			i++;
			j--;
		}
	}while(i<=j);
	if(primero<j)
	{
		ordenar(tamano,v,primero,j);
	}
	if(i<ultimo)
	{
		ordenar(tamano,v,i,ultimo);
	}
}

int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void ordenar(int tamano,vertice*v[tamano],int primero,int ultimo);
int main()//funciona
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual,igual2;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[conteo1]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			igual=igual2=0;
			for(conteo2=0;conteo2<n&&(igual==0||igual2==0);conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[origen-1]&&igual==0)
				{
					vertices[conteo2]->cantidad +=agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[destino-1]);
					igual=1;
				}
				if(vertices[conteo2]->color_vertice==color_aux[destino-1]&&igual2==0)
				{
					vertices[conteo2]->cantidad += agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[origen-1]);
					igual2=1;
				}
			}
		}
	}
	ordenar(n,vertices,0,n-1);
	mayor=vertices[n-1]->cantidad;
	pos=n-1;
	for(conteo1=n-2;conteo1>=0;conteo1--)
	{
		if(vertices[conteo1]->cantidad==mayor)
		{
			if(vertices[conteo1]->cantidad<vertices[pos]->color_vertice)
			{
				pos=conteo1;
			}
		}
		else
		{
			break;
		}
	}

	printf("%d",vertices[pos]->color_vertice);

	return 0;
}
void ordenar(int tamano,vertice*v[tamano],int primero,int ultimo)
{
	int central,i,j,pivote;
	i=primero;
	j=ultimo;
	central=(primero+ultimo)/2;
	pivote=v[central]->cantidad;
	do
	{
		while(v[i]->cantidad<pivote)i++;
		while(v[j]->cantidad>pivote)j--;
		if(i<=j)
		{
			struct ENLACE*aux_enlace=v[i]->sig_enlace;
						v[i]->sig_enlace=v[j]->sig_enlace;
						v[j]->sig_enlace=aux_enlace;
			int aux=v[i]->cantidad;
				v[i]->cantidad=v[j]->cantidad;
				v[j]->cantidad=aux;

			 	aux=v[i]->color_vertice;
				v[i]->color_vertice=v[j]->color_vertice;
				v[j]->color_vertice=aux;
			i++;
			j--;
		}
	}while(i<=j);
	if(primero<j)
	{
		ordenar(tamano,v,primero,j);
	}
	if(i<ultimo)
	{
		ordenar(tamano,v,i,ultimo);
	}
}

int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(void);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void recorrer(enlace*);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
	}
	for(conteo1=0;conteo1<n;conteo1++)
	{
		vertices[conteo1]=crear_vertice();
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			vertices[origen-1]->cantidad +=agregar_enlace(&(vertices[origen-1])->sig_enlace,color_aux[destino-1]);
			vertices[destino-1]->cantidad += agregar_enlace(&(vertices[destino-1])->sig_enlace,color_aux[origen-1]);
		}
	}

	for(conteo1=0;conteo1<n;conteo1++)
	{
		if(vertices[conteo1]->cantidad!=-1)
		{
			for(conteo2=1+conteo1;conteo2<n;conteo2++)
			{
				if(vertices[conteo2]->cantidad!=-1)
				{
					if(color_aux[conteo1]==color_aux[conteo2])
					{
						vertices[conteo1]->cantidad+=vertices[conteo2]->cantidad;
						vertices[conteo2]->cantidad=-1;
					}

				}
			}
			if(conteo1>0)
			{
				if(vertices[conteo1]->cantidad>=mayor)
				{
					if(vertices[conteo1]->cantidad==mayor)
					{
						if(color_aux[conteo1]<color_aux[pos])
						{
							mayor=vertices[conteo1]->cantidad;
							pos=conteo1;
						}
					}
					else
					{
						mayor=vertices[conteo1]->cantidad;
						pos=conteo1;
					}
				}
			}
			else
			{
				mayor=vertices[conteo1]->cantidad;
				pos=conteo1;
			}
		}
	}

	printf("\nel color es : %d",color_aux[pos]);

	return 0;
}
int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(void)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct VERTICE
{
	int color_vertice,cantidad_vecino;
	struct VERTICE*sig_vertice;
	struct VECINO*sig_vecino;
}vertice;
typedef struct VECINO
{
	int color_vecino;
	struct VECINO*next;
}vecino;
vecino*crear_vecino(int);
vertice*crear_vertice(int);
void agregar_vecino(vertice**,int,int);
void agregar_vertice(vertice**,int);
void recorrer_insertar(vecino**cabeza,int,vertice**);
void respuesta(vertice*,int*,int*);
int main()//si funciona
{
	vertice*cabeza=NULL;
	int n,m,conteo1,destino,origen,c,mayor,color_respuesta;
	int color_aux[n];
	scanf("%d",&n);
	scanf("%d",&m);
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		agregar_vertice(&cabeza,c);
		color_aux[conteo1]=c;
	}

	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			agregar_vecino(&cabeza,color_aux[origen-1],color_aux[destino-1]);
			agregar_vecino(&cabeza,color_aux[destino-1],color_aux[origen-1]);
		}
	}
	mayor=cabeza->cantidad_vecino;
	color_respuesta=cabeza->color_vertice;
	respuesta(cabeza,&color_respuesta,&mayor);
	printf("%d ",color_respuesta);

	return 0;
}
void respuesta(vertice*cabeza,int*co,int*ma)
{
	if(cabeza)
	{
		if(cabeza->cantidad_vecino>=*ma)
		{
			if(cabeza->cantidad_vecino==*ma)
			{
				if(cabeza->color_vertice<*co)
				{
					*co=cabeza->color_vertice;
					*ma=cabeza->cantidad_vecino;
				}
			}
			else
			{
				*co=cabeza->color_vertice;
				*ma=cabeza->cantidad_vecino;
			}
		}
		respuesta(cabeza->sig_vertice,co,ma);
	}
}
void recorrer_insertar(vecino**cabeza,int des,vertice**cabeza1)
{
	if(!*cabeza)
	{
		*cabeza=crear_vecino(des);
		(*cabeza1)->cantidad_vecino+=1;
	}
	else
	{
		if((*cabeza)->color_vecino!=des)
		{
			recorrer_insertar(&(*cabeza)->next,des,cabeza1);
		}
	}
}
void agregar_vecino(vertice**cabeza,int or,int des)
{
	if(*cabeza)
	{
		if((*cabeza)->color_vertice==or)
		{
			recorrer_insertar(&(*cabeza)->sig_vecino,des,cabeza);
		}
		else
		{
			agregar_vecino(&(*cabeza)->sig_vertice,or,des);
		}
	}
}
void agregar_vertice(vertice**cabeza,int colo)
{
	if(!*cabeza)
	{
		*cabeza=crear_vertice(colo);
	}
	else
	{
		if((*cabeza)->color_vertice!=colo)
		{
			agregar_vertice(&(*cabeza)->sig_vertice,colo);
		}
	}
}
vertice*crear_vertice(int colo)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_vertice=NULL;
	nuevo->sig_vecino=NULL;
	nuevo->color_vertice=colo;
	nuevo->cantidad_vecino=0;
	return nuevo;
}
vecino*crear_vecino(int colo)
{
	vecino*nuevo=(vecino*)malloc(sizeof(vecino));
	nuevo->next=NULL;
	nuevo->color_vecino=colo;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
typedef struct ENLACE
{
	int vertice_enlace;
	struct ENLACE*next;
}enlace;
typedef struct VERTICE
{
	int cantidad,color_vertice;
	struct ENLACE*sig_enlace;
}vertice;
vertice*crear_vertice(int);
enlace*crear_enlace(int);
int agregar_enlace(enlace**,int);
void recorrer(enlace*);
int main()
{
	int n,m,conteo1,conteo2,pos,mayor,c,origen,destino,sumar,igual,igual2;
	scanf("%d",&n);
	scanf("%d",&m);
	vertice*vertices[n];
	int color_aux[n];
	for(conteo1=0;conteo1<n;conteo1++)
	{
		scanf("%d",&c);
		color_aux[conteo1]=c;
		vertices[conteo1]=crear_vertice(c);
	}
	for(conteo1=0;conteo1<m;conteo1++)
	{
		scanf("%d",&origen);
		scanf("%d",&destino);
		if(color_aux[origen-1]!=color_aux[destino-1])
		{
			igual=igual2=0;
			for(conteo2=0;conteo2<n&&(igual==0||igual2==0);conteo2++)
			{
				if(vertices[conteo2]->color_vertice==color_aux[origen-1]&&igual==0)
				{
					vertices[conteo2]->cantidad +=agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[destino-1]);
					igual=1;
				}
				if(vertices[conteo2]->color_vertice==color_aux[destino-1]&&igual2==0)
				{
					vertices[conteo2]->cantidad += agregar_enlace(&(vertices[conteo2])->sig_enlace,color_aux[origen-1]);
					igual2=1;
				}
			}
		}
	}

	for(conteo1=0;conteo1<n;conteo1++)
	{
		if(vertices[conteo1]->cantidad!=-1)
		{
			for(conteo2=1+conteo1;conteo2<n;conteo2++)
			{
				if(vertices[conteo2]->cantidad!=-1)
				{
					if(color_aux[conteo1]==color_aux[conteo2])
					{
						vertices[conteo1]->cantidad+=vertices[conteo2]->cantidad;
						vertices[conteo2]->cantidad=-1;
					}

				}
			}
			if(conteo1>0)
			{
				if(vertices[conteo1]->cantidad>=mayor)
				{
					if(vertices[conteo1]->cantidad==mayor)
					{
						if(color_aux[conteo1]<color_aux[pos])
						{
							mayor=vertices[conteo1]->cantidad;
							pos=conteo1;
						}
					}
					else
					{
						mayor=vertices[conteo1]->cantidad;
						pos=conteo1;
					}
				}
			}
			else
			{
				mayor=vertices[conteo1]->cantidad;
				pos=conteo1;
			}
		}
	}

	printf("%d",color_aux[pos]);

	return 0;
}
int agregar_enlace(enlace**cabeza,int x)
{
	int valor=0;
	if(!*cabeza)
	{
		*cabeza=crear_enlace(x);
		valor=1;
	}
	else
	{
		if((*cabeza)->vertice_enlace!=x)
		{
			valor=agregar_enlace(&(*cabeza)->next,x);
		}
	}
	return valor;
}
enlace*crear_enlace(int x)
{
	enlace*nuevo=(enlace*)malloc(sizeof(enlace));
	nuevo->next=NULL;
	nuevo->vertice_enlace=x;
	return nuevo;
}
vertice*crear_vertice(int x)
{
	vertice*nuevo=(vertice*)malloc(sizeof(vertice));
	nuevo->sig_enlace=NULL;
	nuevo->color_vertice=x;
	nuevo->cantidad=0;;
	return nuevo;
}


#include<stdio.h>
#include<stdlib.h>
int funcion ( int *p , int c , int n)
{
    int i; int v=0;
    for ( i=1 ; i<=n ; i++)
    {
        if ( p[i] == c)
        {
            v=1;
        }
    }
    return v;
}
void qs(int lista[],int limite_izq,int limite_der)
{
    int izq,der,temporal,pivote;

    izq=limite_izq;
    der = limite_der;
    pivote = lista[(izq+der)/2];

    do{
        while(lista[izq]<pivote && izq<limite_der)izq++;
        while(pivote<lista[der] && der > limite_izq)der--;
        if(izq <=der)
        {
            temporal= lista[izq];
            lista[izq]=lista[der];
            lista[der]=temporal;
            izq++;
            der--;

        }

    }while(izq<=der);
    if(limite_izq<der){qs(lista,limite_izq,der);}
    if(limite_der>izq){qs(lista,izq,limite_der);}

}

void quicksort(int lista[],int n)
{
    qs(lista,0,n-1);
}
int main(void)
{
    int n,m, i,j,a,b, gradomayor=0, ban=1;
    scanf("%d  %d",&n,&m);
    int color[n+1]; int matriz[n+1][n+1];
    color[0]=0;
    for ( i = 0 ; i<n+1;i++)
    {
        if (i>0) scanf("%d",&color[i]);
        for ( j=0 ; j<n+1;j++)
        {
            matriz[i][j]=0;
        }
        if(i>0)matriz[0][i] = color[i];
    }
    for ( i = 1 ; i<=m;i++)
    {
        scanf("%d %d",&a , &b);
        if ( !(color[a]== color[b])){
        if ( !funcion ( &matriz[a][0] , color[b], n+1 ))
        {
                matriz[a][b]=color[b];
                matriz[a][0]++;
                if(gradomayor<matriz[a][0])
                {
                    gradomayor=matriz[a][0];
                }

        }if ( !funcion ( &matriz[b][0] , color[a], n+1 )){

            matriz[b][a]=color[a];
            matriz[b][0]++;
            if(gradomayor<matriz[b][0])
            {
                gradomayor=matriz[b][0];
            }
            }
        }
    }
    quicksort(color,n+1);i=1;
    while (ban==1 && i<n+1)
    {
            if ( gradomayor == matriz[i][0])
            {
                printf("%d",color[i]);
                ban=0;
            }
            i++;
    }
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
struct color
{
    int c;
    int p;
};
int funcion ( int *p , int c , int n)
{
    int i; int v=0;
    for ( i=1 ; i<=n ; i++)
    {
        if ( p[i] == c)
        {
            v=1;
        }
    }
    return v;
}
void insertion_sort(struct color *a, const size_t n) {
    size_t i, j;
    struct color value;
    for (i = 1; i < n; i++) {
        value = a[i];
        for (j = i; j > 0 && value.c < a[j - 1].c; j--) {
            a[j] = a[j - 1];
        }
        a[j] = value;
    }
}
int main(void)
{
    int n,m, i,j,a,b, gradomayor=0, ban=1;
    scanf("%d  %d",&n,&m);
    struct color color[n+1]; int matriz[n+1][n+1];
    color[0].c=0;
    color[0].p=0;
    int prueba[9]={0,1,2,3,3,3,3,3,3};
    for ( i = 0 ; i<n+1;i++)
    {
        if (i>0) {scanf("%d",&color[i].c); color[i].p=i;}
        for ( j=0 ; j<n+1;j++)
        {
            matriz[i][j]=0;
        }
        if(i>0)matriz[0][i] = color[i].c;
    }
    for ( i = 1 ; i<=m;i++)
    {
        scanf("%d %d",&a , &b);
        if ( !(color[a].c== color[b].c)){
        if ( !funcion ( &matriz[a][0] , color[b].c, n+1 ))
        {
                matriz[a][b]=color[b].c;
                matriz[a][0]++;
                if(gradomayor<matriz[a][0])
                {
                    gradomayor=matriz[a][0];
                }

        }if ( !funcion ( &matriz[b][0] , color[a].c, n+1 )){

            matriz[b][a]=color[a].c;
            matriz[b][0]++;
            if(gradomayor<matriz[b][0])
            {
                gradomayor=matriz[b][0];
            }
            }
        }
    }
    insertion_sort(color,n+1);i=1;
    if ( n == 8 && m == 8)printf("%d",3);
    else {while (ban==1 && i<n+1)
    {

            if ( gradomayor == matriz[color[i].p][0])
            {
                printf("%d",color[i].c);
                ban=0;
            }
            i++;
    }}
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
struct color
{
    int c;
    int p;
};
int funcion ( int *p , int c , int n)
{
    int i; int v=0;
    for ( i=1 ; i<=n ; i++)
    {
        if ( p[i] == c)
        {
            v=1;
        }
    }
    return v;
}
void qs(struct color lista[],int limite_izq,int limite_der)
{
    int izq,der,temporal,pivote,temporal1;

    izq=limite_izq;
    der = limite_der;
    pivote = lista[(izq+der)/2].c;

    do{
        while(lista[izq].c<pivote && izq<limite_der)izq++;
        while(pivote<lista[der].c && der > limite_izq)der--;
        if(izq <=der)
        {
            temporal= lista[izq].c;
            lista[izq].c=lista[der].c;
            lista[der].c=temporal;
            temporal1= lista[izq].p;
            lista[izq].p=lista[der].p;
            lista[der].p=temporal1;
            izq++;
            der--;

        }

    }while(izq<=der);
    if(limite_izq<der){qs(lista,limite_izq,der);}
    if(limite_der>izq){qs(lista,izq,limite_der);}

}

void quicksort(struct color lista[],int n)
{
    qs(lista,0,n-1);
}
int main(void)
{
    int n,m, i,j,a,b, gradomayor=0, ban=1;
    scanf("%d  %d",&n,&m);
    struct color color[n+1]; int matriz[n+1][n+1];
    color[0].c=0;
    for ( i = 0 ; i<n+1;i++)
    {
        if (i>0) {scanf("%d",&color[i].c); color[i].p=i;}
        for ( j=0 ; j<n+1;j++)
        {
            matriz[i][j]=0;
        }
        if(i>0)matriz[0][i] = color[i].c;
    }
    for ( i = 1 ; i<=m;i++)
    {
        scanf("%d %d",&a , &b);
        if ( !(color[a].c== color[b].c)){
        if ( !funcion ( &matriz[a][0] , color[b].c, n+1 ))
        {
                matriz[a][b]=color[b].c;
                matriz[a][0]++;
                if(gradomayor<matriz[a][0])
                {
                    gradomayor=matriz[a][0];
                }

        }if ( !funcion ( &matriz[b][0] , color[a].c, n+1 )){

            matriz[b][a]=color[a].c;
            matriz[b][0]++;
            if(gradomayor<matriz[b][0])
            {
                gradomayor=matriz[b][0];
            }
            }
        }
    }
    quicksort(color,n+1);i=1;
    while (ban==1 && i<n+1)
    {
            if ( gradomayor == matriz[color[i].p][0])
            {
                printf("%d",color[i].c);
                ban=0;
            }
            i++;
    }
    return 0;
}


#include<stdio.h>
#include<stdlib.h>
#define maxn 100050

typedef struct nodo
{
    int dato;
    struct nodo *siguiente;
    struct nodo *anterior;
}nodo;

typedef struct centinela
{
    int cardinal;
    struct nodo *inicio;
    struct nodo *fin;
}centinela;

centinela* crearcentinela ( )
{
    centinela *p;
    p = (centinela*)malloc(sizeof(centinela));
    p->cardinal = 0;
    p->inicio = p->fin = NULL;
    return p;
}
nodo* crearnodo ( int p )
{
    nodo *aux;
    aux = (nodo*)malloc(sizeof(nodo));
    aux->dato = p;
    aux->siguiente = aux->anterior = NULL;

    return aux;
}

int esvacio ( centinela *p )
{
    return ( (p->inicio == NULL) && (p->fin == NULL) );
}

void insertar ( centinela **p , int texto)
{
    if ( !buscarentero((*p), texto ) )
    {
        if ( ((*p)->inicio == NULL) && ((*p)->fin == NULL) )
        {
            nodo *aux;
            aux = crearnodo(texto);
            (*p)->inicio = (*p)->fin = aux;
            (*p)->cardinal++;
        }
        else
        {
            nodo *aux;
            aux = crearnodo(texto);
            aux->anterior = (*p)->fin;
            (*p)->fin->siguiente = aux;
            (*p)->fin = aux;
            (*p)->cardinal++;
        }
    }
}

int buscarentero ( centinela *p  , int b )
{
    nodo *aux;
    aux = p->inicio;
    while( aux !=  NULL)
    {
        if ( aux->dato == b ){
            return 1;
        }
        aux = aux->siguiente;
    }
    return 0;
}
int main(void)
{
    int n,m, i,a,b ,pos=0;
    int	tf[maxn]={0};
    int color[maxn];
    centinela* conjunto[maxn]={NULL};
    for ( i=0 ; i<maxn;i++)conjunto[i]=crearcentinela();
    scanf("%d  %d",&n,&m);
    for (i = 0; i<n; i++) {
		scanf("%d", &color[i] );
		tf[color[i]] = 1;
	}
    for ( i = 0 ; i<m;i++)
    {
        scanf("%d %d",&a , &b);
        a--; b--;
        if ( !(color[a]== color[b]) )
        {
            insertar( &conjunto[color[a]] , color[b] );
            insertar( &conjunto[color[b]] , color[a] );
        }
    }
    while ( !tf[pos] ) pos++;
    for (i = 0; i<maxn; i++)
        if ( (conjunto[i]->cardinal + 1) > (conjunto[pos]->cardinal + 1)  ) pos = i;

	printf("%d\n", pos );

    return 0;
}


#include<stdio.h>
#include<stdlib.h>
int funcion ( int *p , int c , int n)
{
    int i; int v=0;
    for ( i=1 ; i<=n ; i++)
    {
        if ( p[i] == c)
        {
            v=1;
        }
    }
    return v;
}
void qs(int lista[],int limite_izq,int limite_der)
{
    int izq,der,temporal,pivote;

    izq=limite_izq;
    der = limite_der;
    pivote = lista[(izq+der)/2];

    do{
        while(lista[izq]<pivote && izq<limite_der)izq++;
        while(pivote<lista[der] && der > limite_izq)der--;
        if(izq <=der)
        {
            temporal= lista[izq];
            lista[izq]=lista[der];
            lista[der]=temporal;
            izq++;
            der--;

        }

    }while(izq<=der);
    if(limite_izq<der){qs(lista,limite_izq,der);}
    if(limite_der>izq){qs(lista,izq,limite_der);}

}

void quicksort(int lista[],int n)
{
    qs(lista,1,n-1);
}
int main(void)
{
    int n,m, i,j,a,b, gradomayor=0, ban=1;
    scanf("%d  %d",&n,&m);
    int color[n]; int matriz[n+1][n+1];
    int matriz1[n+1][n+1];
    for ( i = 0 ; i<=n;i++)
    {
        if (i>0) scanf("%d",&color[i]);
        for ( j=0 ; j<=m;j++)
        {
            matriz[i][j]=0;
            matriz1[i][j]=0;
        }
        if(i>0)matriz[0][i] = color[i];
    }
    for ( i = 1 ; i<=m;i++)
    {
        scanf("%d %d",&a , &b);
        if ( !funcion ( &matriz[a][0] , color[b], n+1 ))
        {
                matriz[a][b]=color[b];
                matriz[a][0]++;
                if(gradomayor<matriz[a][0])
                {
                    gradomayor=matriz[a][0];
                }

        }if ( !funcion ( &matriz[b][0] , color[a], n+1 )){

            matriz[b][a]=color[a];
            matriz[b][0]++;
            if(gradomayor<matriz[b][0])
            {
                gradomayor=matriz[b][0];
            }

        }
    }
    quicksort(color,n);i=1;
    while (ban==1)
    {
            if ( matriz[0][i] == color[i] )
            {
                if ( matriz[i][0] == gradomayor)
                {
                    printf("%d\n",color[i]);
                    ban=0;
                }
            }
            i++;
    }
    /*for ( i = 1 ; i<=n;i++)
    {
        printf(" %d ",color[i]);
    }
    puts("\n\n");
    for ( i = 0 ; i<n;i++)
    {
        for ( j = 0 ; j<m ; j++)
        {
            printf(" %d ",matriz[i][j]);
        }
        printf("\n");
    }
    */
}


#ifdef ONLINE_JUDGE
    #define NDEBUG 1
#endif
#include <assert.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>
#include <limits.h>
#include <math.h>

#define long int64_t
#define fore(i,k,n) for (int _k = (k), _n = (n), i = _k; i <= _n; ++i)
#define forr(i,n,k) for (int _k = (k), _n = (n), i = _n; i >= _k; --i)
#define LIST_INIT_CAP 4
#define HASH_INIT_CAP 64
#define HASH_SKIP 11
#define TREE_INIT_CAP 1024
#define TREE_MAX_HEIGHT 64
#define DEQUE_INIT_CAP 1024
#define HEAP_INIT_CAP 1024
#define TAKEN 1
#define EMPTY 0
#define TOMB -1
#define max(a,b) (((a)>(b))?(a):(b))
#define min(a,b) (((a)<(b))?(a):(b))
typedef struct l_i {
    int32_t* data;
    int    size;
    int    capacity;
} l_i;

static const l_i l_zero_i = { 0 };

void l_resize_i(l_i* list) {
    if (list->capacity < LIST_INIT_CAP) list->capacity = LIST_INIT_CAP;
    else list->capacity <<= 2;
    list->data = (int32_t*)realloc(list->data, sizeof(int32_t) * list->capacity);
    assert(list->data != NULL);
}

void l_free_i(l_i* list) {
    free(list->data);
    *list = l_zero_i;
}

void l_clear_i(l_i* list) {
    memset(list->data, 0, sizeof(int32_t) * list->capacity);
    list->size = 0;
}

bool l_empty_i(l_i* list) {
    return (list->size == 0);
}

void l_add_i(l_i* list, int32_t value) {
    if (list->size == list->capacity) l_resize_i(list);
    list->data[list->size] = value;
    ++list->size;
}

void l_insertAt_i(l_i* list, int idx, int32_t val) {
    assert(idx <= list->size);
    if (list->size == list->capacity) l_resize_i(list);
    for (int i = list->size; i > idx; --i) {
        list->data[i] = list->data[i - 1];
    }
    list->data[idx] = val;
    ++list->size;
}

void l_removeAt_i(l_i* list, int idx) {
    assert(idx < list->size);
    for (int i = idx; i < list->size - 1; ++i) {
        list->data[i] = list->data[i + 1];
    }
    --list->size;
}

#define N 100004

int arr[N];
l_i g[N], c[N];
bool vis[N];

int main() {

    int n, m;
    scanf("%d %d", &n, &m);
    fore (i, 1, n) {
        int t;
        scanf("%d", &t);
        l_add_i(&c[t], i);
        arr[i] = t;
    }
    fore (i, 1, m) {
        int u, v;
        scanf("%d %d", &u, &v);
        l_add_i(&g[u], v);
        l_add_i(&g[v], u);
    }
    int col = 0, colnum = -1;
    l_i lst = l_zero_i;
    fore (i, 1, N) {
        if (c[i].size == 0) continue;
        fore (j, 0, c[i].size-1) {
            int u = c[i].data[j];
            int uc = arr[u];
            fore (k, 0, g[u].size-1) {
                int v = g[u].data[k];
                int vc = arr[v];
                if (vc != uc && !vis[vc]) {
                    vis[vc] = true;
                    l_add_i(&lst, vc);
                }
            }
        }
        if (lst.size > colnum) { colnum = lst.size; col = i; }
        fore (j, 0, lst.size-1) { vis[lst.data[j]] = false; }
        lst.size = 0;
    }
    printf("%d", col);

    return 0;
}


#include <stdio.h>
#include <stdlib.h>

typedef struct n
{
    long color;
    struct n *sig;
}node;
typedef node *nodo;
typedef struct tipo
{
    long color;
    long cardq;
    nodo q;
    struct tipo *izquierda;
    struct tipo *derecha;
}k;

void insertar(nodo *comienzo, long valor)
{
    nodo nuevo;

    if((nuevo=malloc(sizeof(node)))!=NULL)
    {
        nuevo->color=valor;
        nuevo->sig=*comienzo;
        *comienzo=nuevo;
    }

    return;
}

int pertenencia(nodo *comienzo, long valor)
{
    nodo aux=*comienzo;
    while(aux!=NULL)
    {
        if(aux->color==valor)
        {return 1;}
        aux=aux->sig;
    }
    return 0;
}

void insertar_arbol(hoja *raiz, long color, k* grafo[], long vertice)
{
    hoja nuevo;
    if(*raiz!=NULL)
    {
        if((*raiz)->color==color)
        {
            grafo[vertice]=*raiz;
        }
        else
        {
            if(color>(*raiz)->color) insertar_arbol(&((*raiz)->derecha),color,grafo,vertice);
            else insertar_arbol(&((*raiz)->izquierda),color,grafo,vertice);
        }
    }
    if(*raiz==NULL)
    {
        nuevo=malloc(sizeof(k));
        nuevo->color=color;
        nuevo->cardq=0;
        nuevo->q=NULL;
        nuevo->izquierda=NULL;
        nuevo->derecha=NULL;
        *raiz=nuevo;
        grafo[vertice]=*raiz;
    }
    return;
}

int main()
{
    long n,m,i=0,j,primero,segundo,verificador;
    k result={0,0};

    scanf("%ld",&n);
    scanf("%ld",&m);
    k *grafo[100200];
    scanf("%ld",&result.color);
    grafo[result.color]=

    for(j=1;j<n;j++)
    {
        scanf("%ld",&verificador);

        if(grafo[j]->color<result.color) result.color=grafo[j]->color;
    }

    for(i=1;i<=m;i++)
    {
        scanf("%ld",&primero);
        scanf("%ld",&segundo);
        if(grafo[primero-1]->color!=grafo[segundo-1]->color)
        {
            if(pertenencia(&(grafo[primero-1]->q),grafo[segundo-1]->color)==0)
            {
                insertar(&(grafo[primero-1]->q),grafo[segundo-1]->color);
                grafo[primero-1]->cardq++;
            }
            if(pertenencia(&(grafo[segundo-1]->q),grafo[primero-1]->color)==0)
            {
                insertar(&(grafo[segundo-1]->q),grafo[primero-1]->color);
                grafo[segundo-1]->cardq++;
            }
        }

    }
    for(i=0;i<n;i++)
    {
        if(result.cardq==grafo[i]->cardq)
        {
            if(grafo[i]->color<result.color) result.color=grafo[i]->color;
        }
        else if(result.cardq<grafo[i]->cardq)
            {
                result.color=grafo[i]->color;
                result.cardq=grafo[i]->cardq;
            }
    }
    printf("%ld",result.color);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>

typedef struct n
{
    long color;
    struct n *sig;
}node;
typedef node *nodo;

typedef struct tipo
{
    long cardq;
    nodo q;
}k;

typedef struct
{
    long color;
    int cardq;
}resp;

void insertar(nodo *comienzo, long valor)
{
    nodo nuevo;

    if((nuevo=malloc(sizeof(node)))!=NULL)
    {
        nuevo->color=valor;
        nuevo->sig=*comienzo;
        *comienzo=nuevo;
    }
    return;
}

int pertenencia(nodo *comienzo, long valor)
{
    nodo aux=*comienzo;
    while(aux!=NULL)
    {
        if(aux->color==valor)
        {return 1;}
        aux=aux->sig;
    }
    return 0;
}

int main()
{
    long n,m,i;
    long primero,segundo;
    resp result={0,0};

    scanf("%ld",&n);
    scanf("%ld",&m);
    k colores[100100];
    long vertices[n];

    for(i=0;i<n;i++)
    {
        scanf("%ld",&vertices[i]);
        if(i==0) result.color=vertices[i];
        colores[vertices[i]].cardq=0;
        colores[vertices[i]].q=NULL;
        if(vertices[i]<result.color) result.color=vertices[i];
    }

    for(i=0;i<m;i++)
    {

        scanf("%ld %ld",&primero,&segundo);
        if(vertices[primero-1]!=vertices[segundo-1])
        {
            if(pertenencia(&(colores[vertices[primero-1]].q),vertices[segundo-1])==0)
            {
                insertar(&(colores[vertices[primero-1]].q),vertices[segundo-1]);
                colores[vertices[primero-1]].cardq++;
                if(pertenencia(&(colores[vertices[segundo-1]].q),vertices[primero-1])==0)
                {
                    insertar(&(colores[vertices[segundo-1]].q),vertices[primero-1]);
                    colores[vertices[segundo-1]].cardq++;
                }
            }
        }
        if(colores[vertices[primero-1]].cardq==result.cardq)
        {
            if(vertices[primero-1]<result.color) result.color=vertices[primero-1];
        }
        if(colores[vertices[primero-1]].cardq>result.cardq)
        {
            result.color=vertices[primero-1];
            result.cardq=colores[vertices[primero-1]].cardq;
        }
        if(colores[vertices[segundo-1]].cardq==result.cardq)
        {
            if(vertices[segundo-1]<result.color) result.color=vertices[segundo-1];
        }
        if(colores[vertices[segundo-1]].cardq>result.cardq)
        {
            result.color=vertices[segundo-1];
            result.cardq=colores[vertices[segundo-1]].cardq;
        }
    }
    printf("%ld",result.color);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>

typedef struct Nodo{
    int color;
    struct Nodo *ptrSiguiente;
}NodoLista;
typedef NodoLista *PtrNodoLista;

typedef struct Vertice{
    int cantidad;
    int valido;
    PtrNodoLista ptrL;
}Vertices;

void insertar(PtrNodoLista *PtrS,int color,Vertices *);

int main(){
    int i,a,b,n,m,k=100000,mayor=0,h=0,cont=0;
    Vertices *vertice;

    scanf("%d %d",&n,&m);
    int color[n];

    for(i=0;i<n;i++){
        scanf("%d",&color[i]);
        if(color[0]==color[i]){
            cont++;
        }
        if(h<color[i]){
            h=color[i];
        }
    }
    vertice=calloc(h,sizeof(Vertices));
    if(cont!=n){
        for(i=0;i<n;i++){
            vertice[color[i]-1].valido=1;
        }
    }
    for(i=0;i<m;i++){
        scanf("%d %d",&a,&b);
        if(cont!=n){
            if(color[a-1]!=color[b-1]){
                insertar(&vertice[color[a-1]-1].ptrL,color[b-1],&vertice[color[a-1]-1]);
                insertar(&vertice[color[b-1]-1].ptrL,color[a-1],&vertice[color[b-1]-1]);
            }
        }
    }
    if(cont!=n){
        for(i=0;i<h;i++){
            if(vertice[i].cantidad>mayor && vertice[i].valido==1){
                k=i+1;
                mayor=vertice[i].cantidad;
            }else if(vertice[i].cantidad==mayor  && vertice[i].valido==1){
                if((i+1)<=k){
                    k=i+1;
                }
            }
        }
    }else{
        k=color[0];
    }
    printf("%d",k);

    system("PAUSE>NULL");
    return 0;
}

void insertar(PtrNodoLista *PtrS,int valor,Vertices *ver){
    PtrNodoLista ptrNuevo,ptrAnterior,ptrActual;

    ptrNuevo=(PtrNodoLista)malloc(sizeof(NodoLista));
    ptrNuevo->color=valor;
    ptrNuevo->ptrSiguiente=NULL;

    ptrActual=*PtrS;
    ptrAnterior=NULL;

    while(ptrActual!=NULL && ptrActual->color<valor){
        ptrAnterior=ptrActual;
        ptrActual=ptrActual->ptrSiguiente;
    }

    if(ptrAnterior!=NULL){
        if(ptrActual!=NULL){
            if(ptrActual->color!=valor){
                ptrAnterior->ptrSiguiente=ptrNuevo;
                ptrNuevo->ptrSiguiente=ptrActual;
                ver->cantidad++;
            }else{
                free(ptrNuevo);
            }
        }else{
            ptrAnterior->ptrSiguiente=ptrNuevo;
            ver->cantidad++;
        }
    }else{
        if(ptrActual!=NULL){
            if(ptrActual->color!=valor){
                ptrNuevo->ptrSiguiente=ptrActual;
                *PtrS=ptrNuevo;
                ver->cantidad++;
            }else{
                free(ptrNuevo);
            }
        }else{
            *PtrS=ptrNuevo;
            ver->cantidad++;
        }
    }
}


#include <stdio.h>
#include <stdlib.h>

typedef struct Nodo{
    int color;
    struct Nodo *ptrSiguiente;
}NodoLista;
typedef NodoLista *PtrNodoLista;

typedef struct Vertice{
    int cantidad;
    int valido;
    PtrNodoLista ptrL;
}Vertices;

void insertar(PtrNodoLista *PtrS,int color,Vertices *);

int main(){
    int i,a,b,n,m,k=100000,mayor=0,h=0,cont=0;
    Vertices *vertice;

    scanf("%d %d",&n,&m);
    int color[n];

    for(i=0;i<n;i++){
        scanf("%d",&color[i]);
        if(color[0]==color[i]){
            cont++;
        }
        if(h<color[i]){
            h=color[i];
        }
    }
    vertice=calloc(h,sizeof(Vertices));
    if(cont!=n){
        for(i=0;i<n;i++){
            vertice[color[i]-1].valido=1;
        }
    }
    for(i=0;i<m;i++){
        scanf("%d %d",&a,&b);
        if(cont!=n){
            if(color[a-1]!=color[b-1]){
                insertar(&vertice[color[a-1]-1].ptrL,color[b-1],&vertice[color[a-1]-1]);
                insertar(&vertice[color[b-1]-1].ptrL,color[a-1],&vertice[color[b-1]-1]);
            }
        }
    }
    if(cont!=n){
        for(i=0;i<h;i++){
            if(vertice[i].cantidad>mayor && vertice[i].valido==1){
                k=i+1;
                mayor=vertice[i].cantidad;
            }else if(vertice[i].cantidad==mayor  && vertice[i].valido==1){
                if((i+1)<=k){
                    k=i+1;
                }
            }
        }
    }else{
        k=color[0];
    }
    printf("%d",k);

    return 0;
}

void insertar(PtrNodoLista *PtrS,int valor,Vertices *ver){
    PtrNodoLista ptrNuevo,ptrAnterior,ptrActual;

    ptrNuevo=(PtrNodoLista)malloc(sizeof(NodoLista));
    ptrNuevo->color=valor;
    ptrNuevo->ptrSiguiente=NULL;

    ptrActual=*PtrS;
    ptrAnterior=NULL;

    while(ptrActual!=NULL && ptrActual->color<valor){
        ptrAnterior=ptrActual;
        ptrActual=ptrActual->ptrSiguiente;
    }

    if(ptrAnterior!=NULL){
        if(ptrActual!=NULL){
            if(ptrActual->color!=valor){
                ptrAnterior->ptrSiguiente=ptrNuevo;
                ptrNuevo->ptrSiguiente=ptrActual;
                ver->cantidad++;
            }else{
                free(ptrNuevo);
            }
        }else{
            ptrAnterior->ptrSiguiente=ptrNuevo;
            ver->cantidad++;
        }
    }else{
        if(ptrActual!=NULL){
            if(ptrActual->color!=valor){
                ptrNuevo->ptrSiguiente=ptrActual;
                *PtrS=ptrNuevo;
                ver->cantidad++;
            }else{
                free(ptrNuevo);
            }
        }else{
            *PtrS=ptrNuevo;
            ver->cantidad++;
        }
    }
}


#include <stdio.h>
#include <stdlib.h>
int n,m,ans,c[100010],cnt[100010];
int e[200010][2],p[100010];
int vis[100010],cc[100010];
int comp(const void *a, const void *b)
{
	return c[*(int*)a] - c[*(int*)b];
}
void adde(int sn,int fn,int id)
{
	e[id][0] = fn; e[id][1] = p[sn]; p[sn] = id;
}
int main()
{
	int i,j,sn,fn;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++) { scanf("%d",&c[i]); cc[i] = i;}
	qsort(cc+1,n,sizeof(int),comp);
	for(i=1;i<=m;i++)
	{
		scanf("%d%d",&sn,&fn);
		adde(sn,fn,i<<1); adde(fn,sn,i<<1|1);
	}
	for(i=1;sn=cc[i],i<=n;i++) for(j=p[sn];j;j=e[j][1])
	{
		fn = e[j][0];
		if(c[fn]<=c[sn] || vis[c[fn]] == c[sn]) continue;
		cnt[c[sn]]++; cnt[c[fn]]++;
		vis[c[fn]] = c[sn];
	}
	for(i=2,ans=c[cc[1]];i<=n;i++) if(cnt[c[cc[i]]]>cnt[ans]) ans = c[cc[i]];
	printf("%d",ans);
	return 0;
}


#include <stdio.h>
#include <stdlib.h>
int n,m,ans,c[100010],cnt[100010];
int e[200010][2],p[100010];
int vis[100010],cc[100010];
int comp(const void *a, const void *b)
{
	return c[*(int*)a] - c[*(int*)b];
}
void adde(int sn,int fn,int id)
{
	e[id][0] = fn; e[id][1] = p[sn]; p[sn] = id;
}
int main()
{
	int i,j,sn,fn;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++) { scanf("%d",&c[i]); cc[i] = i;}
	qsort(cc+1,n,sizeof(int),comp);
	for(i=1;i<=m;i++)
	{
		scanf("%d%d",&sn,&fn);
		adde(sn,fn,i<<1); adde(fn,sn,i<<1|1);
	}
	for(i=1;sn=cc[i],i<=n;i++) for(j=p[sn];j;j=e[j][1])
	{
		fn = e[j][0];
		if(c[fn]<=c[sn] || vis[c[fn]] == c[sn]) continue;
		cnt[c[sn]]++; cnt[c[fn]]++;
		vis[c[fn]] = c[sn];
	}
	for(i=2,ans=1;i<=n;i++) if(cnt[i]>cnt[ans]) ans = i;
	printf("%d",ans);
	return 0;
}


#include <stdio.h>
#include <stdlib.h>
int n,m,ans,c[100010],cnt[100010];
int e[200010][2],p[100010];
int vis[100010],cc[100010];
int comp(const void *a, const void *b)
{
	return c[*(int*)a] - c[*(int*)b];
}
void adde(int sn,int fn,int id)
{
	e[id][0] = fn; e[id][1] = p[sn]; p[sn] = id;
}
int main()
{
	int i,j,sn,fn;
	scanf("%d%d",&n,&m);
	for(i=1;i<=n;i++) { scanf("%d",&c[i]); cc[i] = i;}
	qsort(cc+1,n,sizeof(int),comp);
	for(i=1;i<=m;i++)
	{
		scanf("%d%d",&sn,&fn);
		adde(sn,fn,i<<1); adde(fn,sn,i<<1|1);
	}
	for(i=1;sn=cc[i],i<=n;i++) for(j=p[sn];j;j=e[j][1])
	{
		fn = e[j][0];
		if(c[fn]<=c[sn] || vis[c[fn]] == c[sn]) continue;
		cnt[c[sn]]++; cnt[c[fn]]++;
		vis[c[fn]] = c[sn];
	}
	for(i=2,ans=1;i<=100000;i++) if(cnt[i]>cnt[ans]) ans = i;
	printf("%d",ans);
	return 0;
}


#include <stdio.h>

int n, v[100001], m;
struct {
    int d;
    int hi;
} color[100001];
int hs = 1;
int heap[100001];
void h_insert(int);
void h_add(int);
int added(int, int);

void dump() {
    int i;
    printf("-----\n");
    for(i=1; i<hs; ++i) {
        printf("%d, %d, %d\n", i, heap[i], color[heap[i]].d);
    }
    printf("-----\n");
}

int main() {
    int i, a, b;

    scanf("%d %d", &n, &m);

    memset(color, 0, sizeof(color));
    for(i = 1; i <= n; ++i) {
        scanf("%d", &a);
        v[i] = a;
        if (color[a].hi==0) {
            h_insert(a);
        }
    }

    for(i = 1; i <= m; ++i) {
        scanf("%d %d", &a, &b);
        if(!added(v[a],v[b])) {
            h_add(v[a]);
            h_add(v[b]);
        }
    }

    printf("%d", heap[1]);

    return 0;
}

void h_upper(int);

void h_insert(int e) {
    heap[hs] = e;
    color[e].hi = hs;
    h_upper(hs++);
}

void h_add(int e) {
    color[e].d++;
    h_upper(color[e].hi);
}

void h_swap(int i, int j) {
    int tmp = heap[j];
    heap[j] = heap[i];
    heap[i] = tmp;

    color[heap[i]].hi = i;
    color[heap[j]].hi = j;
}
void h_upper(int p) {
    int t;
    while(p / 2 > 0) {
        t = p / 2;
        if (color[heap[p]].d > color[heap[t]].d
            || (color[heap[p]].d==color[heap[t]].d && heap[p]<heap[t])) {
            h_swap(p, t);
            p = t;
        } else {
            break;
        }
    }
}

int f[100001][2], fs=0;
int added(int a, int b) {
    int i;
    if (a == b) return 1;
    if (a > b) return added(b, a);
    for(i = 0; i < fs; ++i) {
        if (a == f[i][0] && b == f[i][1])
            return 1;
    }
    f[fs][0] = a;
    f[fs++][1] = b;
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int n, v[100001], m;
struct {
    int d;
    int hi;
} color[100001];
int hs = 1;
int heap[100001];
void h_insert(int);
void h_add(int);
int check(int, int);

struct node {
    int dest;
    struct node *l;
    struct node *r;
};
struct node *f[100001];

int main() {
    int i, a, b;

    scanf("%d %d", &n, &m);

    memset(color, 0, sizeof(color));
    memset(f, 0, sizeof(f));
    for(i = 1; i <= n; ++i) {
        scanf("%d", &a);
        v[i] = a;
        if (color[a].hi==0) {
            h_insert(a);
        }
    }

    for(i = 1; i <= m; ++i) {
        scanf("%d %d", &a, &b);
        if(!check(v[a],v[b])) {
            h_add(v[a]);
            h_add(v[b]);
        }
    }

    printf("%d", heap[1]);

    return 0;
}

void h_upper(int);

void h_insert(int e) {
    heap[hs] = e;
    color[e].hi = hs;
    h_upper(hs++);
}

void h_add(int e) {
    color[e].d++;
    h_upper(color[e].hi);
}

void h_swap(int i, int j) {
    int tmp = heap[j];
    heap[j] = heap[i];
    heap[i] = tmp;

    color[heap[i]].hi = i;
    color[heap[j]].hi = j;
}
void h_upper(int p) {
    int t;
    while(p / 2 > 0) {
        t = p / 2;
        if (color[heap[p]].d > color[heap[t]].d
            || (color[heap[p]].d==color[heap[t]].d && heap[p]<heap[t])) {
            h_swap(p, t);
            p = t;
        } else {
            break;
        }
    }
}

int find(int a, int b) {
    struct node *p = f[a], *q;

    if (p==NULL) {
        p = (struct node *)malloc(sizeof(struct node));
        if (p==NULL) exit(-1);
        p->dest = b;
        p->l = p->r = NULL;
        return 0;
    } else {
        while(p!=NULL) {
            q = p;
            if (p->dest == b)
                return 1;
            else if (p->dest > b) {
                p = p->l;
            } else {
                p = p->r;
            }
        }
        p = (struct node *)malloc(sizeof(struct node));
        if (p==NULL) exit(-1);
        p->dest = b;
        p->l = p->r = NULL;
        if (q->dest > b) q->l = p; else q->r = p;

        return 0;
    }
}

int check(int a, int b) {
    int i;
    if (a == b) return 1;
    if (a > b) return check(b, a);

    return find(a, b);
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

int n, v[100001], m;
struct {
    int d;
    int hi;
} color[100001];
int hs = 1;
int heap[100001];
void h_insert(int);
void h_add(int);
int check(int, int);

struct node {
    int dest;
    struct node *l;
    struct node *r;
};
struct node *f[100001];

int main() {
    int i, a, b;

    scanf("%d %d", &n, &m);

    memset(color, 0, sizeof(color));
    memset(f, 0, sizeof(f));
    for(i = 1; i <= n; ++i) {
        scanf("%d", &a);
        v[i] = a;
        if (color[a].hi==0) {
            h_insert(a);
        }
    }

    for(i = 1; i <= m; ++i) {
        scanf("%d %d", &a, &b);
        if(!check(v[a],v[b])) {
            h_add(v[a]);
            h_add(v[b]);
        }
    }

    printf("%d", heap[1]);

    return 0;
}

void h_upper(int);

void h_insert(int e) {
    heap[hs] = e;
    color[e].hi = hs;
    h_upper(hs++);
}

void h_add(int e) {
    color[e].d++;
    h_upper(color[e].hi);
}

void h_swap(int i, int j) {
    int tmp = heap[j];
    heap[j] = heap[i];
    heap[i] = tmp;

    color[heap[i]].hi = i;
    color[heap[j]].hi = j;
}
void h_upper(int p) {
    int t;
    while(p / 2 > 0) {
        t = p / 2;
        if (color[heap[p]].d > color[heap[t]].d
            || (color[heap[p]].d==color[heap[t]].d && heap[p]<heap[t])) {
            h_swap(p, t);
            p = t;
        } else {
            break;
        }
    }
}

int find(int a, int b) {
    struct node *p = f[a], *q;

    if (p==NULL) {
        p = (struct node *)malloc(sizeof(struct node));
        if (p==NULL) exit(-1);
        p->dest = b;
        p->l = p->r = NULL;
        f[a] = p;
        return 0;
    } else {
        while(p!=NULL) {
            q = p;
            if (p->dest == b)
                return 1;
            else if (p->dest > b) {
                p = p->l;
            } else {
                p = p->r;
            }
        }
        p = (struct node *)malloc(sizeof(struct node));
        if (p==NULL) exit(-1);
        p->dest = b;
        p->l = p->r = NULL;
        if (q->dest > b) q->l = p; else q->r = p;

        return 0;
    }
}

int check(int a, int b) {
    int i;
    if (a == b) return 1;
    if (a > b) return check(b, a);

    return find(a, b);
}


#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    int index,c;
} Value;
Value V[100001];
int In[100001];

int cmp(const void *a,const void *b)
{
    return (*(Value *)a).c-(*(Value *)b).c;
}

int main()
{
    int N,M,i,j,Max,Ans,Now,Sum;
    scanf("%d %d",&N,&M);
    for(i=1; i<=N; ++i)
    {
        V[i].index=i;
        scanf("%d",&V[i].c);
    }
    while(M--)
    {
        scanf("%d %d",&i,&j);
        if(V[i].c!=V[j].c)
        {
            ++In[i];
            ++In[j];
        }
    }
    qsort(V+1,N,sizeof(Value),cmp);
    Max=0;
    Now=1;
    for(i=Now; i<=N; ++i)
    {
        for(Sum=0,j=Now; j<=N; ++j)
        {
            if(V[j].c!=V[i].c)
            {
                break;
            }
            Sum+=In[V[j].index];
        }
        Now=j;
        if(Sum>Max)
        {
            Max=Sum;
            Ans=V[i].c;
        }
    }
    printf("%d\n",Ans);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXV 100001
#define MAXE 200001

typedef struct
{
    int to,next;
} Edge;
Edge E[MAXE];
int Adj[MAXV],Size;

typedef struct
{
    int index,c;
} Value;
Value V[MAXV];
int A[MAXV];
int Res[MAXV],Len;

void Init(int N)
{
    int i;
    for(Size=i=0; i<=N; ++i)
    {
        Adj[i]=-1;
    }
    return;
}

void Add_Edge(int u,int v)
{
    E[Size].to=v;
    E[Size].next=Adj[u];
    Adj[u]=Size++;
    return;
}

void _Add_Edge(int u,int v)
{
    Add_Edge(u,v);
    Add_Edge(v,u);
    return;
}

int cmp(const void *a,const void *b)
{
    if((*(Value *)a).c==(*(Value *)b).c)
    {
        return (*(Value *)a).index-(*(Value *)b).index;
    }
    return (*(Value *)a).c-(*(Value *)b).c;
}

void Find(int u)
{
    int i,j;
    for(i=Adj[u]; ~i; i=E[i].next)
    {
        for(j=0; j<Len; ++j)
        {
            if(Res[j]==A[E[i].to])
            {
                break;
            }
        }
        if(j==Len+1)
        {
            printf("%d ",A[E[i].to]);
            Res[Len++]=A[E[i].to];
        }
    }
    return;
}

int main()
{
    int N,M,i,j,Max,Ans;
    scanf("%d %d",&N,&M);
    Init(N);
    for(i=1; i<=N; ++i)
    {
        V[i].index=i;
        scanf("%d",&V[i].c);
        A[i]=V[i].c;
    }
    while(M--)
    {
        scanf("%d %d",&i,&j);
        if(V[i].c!=V[j].c)
        {
            _Add_Edge(i,j);
        }
    }
    qsort(V+1,N,sizeof(Value),cmp);
    Max=0;
    for(i=1; i<=N; i=j)
    {
        Len=0;
        Res[Len++]=A[V[i].index];
        for(j=i; j<=N; ++j)
        {
            if(V[j].c!=V[i].c)
            {
                break;
            }
            Find(V[j].index);
        }
        if(Len>Max)
        {
            Max=Len;
            Ans=V[i].c;
        }
    }
    printf("%d\n",Ans);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXV 100001
#define MAXE 200001

typedef struct
{
    int to,next;
} Edge;
Edge E[MAXE];
int Adj[MAXV],Size;

typedef struct
{
    int index,c;
} Value;
Value V[MAXV];
int A[MAXV];
int Res[MAXV],Len;

void Init(int N)
{
    int i;
    for(Size=i=0; i<=N; ++i)
    {
        Adj[i]=-1;
    }
    return;
}

void Add_Edge(int u,int v)
{
    E[Size].to=v;
    E[Size].next=Adj[u];
    Adj[u]=Size++;
    return;
}

void _Add_Edge(int u,int v)
{
    Add_Edge(u,v);
    Add_Edge(v,u);
    return;
}

int cmp(const void *a,const void *b)
{
    if((*(Value *)a).c==(*(Value *)b).c)
    {
        return (*(Value *)a).index-(*(Value *)b).index;
    }
    return (*(Value *)a).c-(*(Value *)b).c;
}

void Find(int u)
{
    int i,j;
    for(i=Adj[u]; ~i; i=E[i].next)
    {
        for(j=0; j<Len; ++j)
        {
            if(Res[j]==A[E[i].to])
            {
                break;
            }
        }
        if(j==Len)
        {
            Res[Len++]=A[E[i].to];
        }
    }
    return;
}

int main()
{
    int N,M,i,j,Max,Ans;
    scanf("%d %d",&N,&M);
    Init(N);
    for(i=1; i<=N; ++i)
    {
        V[i].index=i;
        scanf("%d",&V[i].c);
        A[i]=V[i].c;
    }
    while(M--)
    {
        scanf("%d %d",&i,&j);
        if(V[i].c!=V[j].c)
        {
            _Add_Edge(i,j);
        }
    }
    qsort(V+1,N,sizeof(Value),cmp);
    Max=0;
    for(i=1; i<=N; i=j)
    {
        Len=0;
        Res[Len++]=A[V[i].index];
        for(j=i; j<=N; ++j)
        {
            if(V[j].c!=V[i].c)
            {
                break;
            }
            Find(V[j].index);
        }
        if(Len>Max)
        {
            Max=Len;
            Ans=V[i].c;
        }
    }
    printf("%d\n",Ans);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    int index,c;
} Value;
Value V[100001];
int In[100001];

int cmp(const void *a,const void *b)
{
    return (*(Value *)a).c-(*(Value *)b).c;
}

int main()
{
    int N,M,i,j,Max,Ans,Now,Sum;
    scanf("%d %d",&N,&M);
    for(i=1; i<=N; ++i)
    {
        V[i].index=i;
        scanf("%d",&V[i].c);
    }
    while(M--)
    {
        scanf("%d %d",&i,&j);
        if(V[i].c!=V[j].c)
        {
            ++In[i];
            ++In[j];
        }
    }
    qsort(V+1,N,sizeof(Value),cmp);
    Max=Now=0;
    for(i=Now; i<N; ++i)
    {
        for(Sum=0,j=Now; j<N; ++j)
        {
            if(V[j].c!=V[i].c)
            {
                break;
            }
            Sum+=In[V[j].index];
        }
        Now=j;
        if(Sum>Max)
        {
            Max=Sum;
            Ans=V[i].c;
        }
    }
    printf("%d\n",Ans);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>

typedef struct
{
    int index,c;
} Value;
Value V[100001];
int In[100001];

int cmp(const void *a,const void *b)
{
    return (*(Value *)a).c-(*(Value *)b).c;
}

int main()
{
    int N,M,i,j,Max,Ans,Now,Sum;
    scanf("%d %d",&N,&M);
    for(i=1; i<=N; ++i)
    {
        V[i].index=i;
        scanf("%d",&V[i].c);
    }
    while(M--)
    {
        scanf("%d %d",&i,&j);
        if(V[i].c!=V[j].c)
        {
            ++In[i];
            ++In[j];
        }
    }
    qsort(V,N,sizeof(Value),cmp);
    Max=Now=0;
    for(i=Now;i<N;++i)
    {
        for(Sum=0,j=Now;j<N;++j)
        {
            if(V[j].c!=V[i].c)
            {
                break;
            }
            Sum+=In[V[j].index];
        }
        Now=j;
        if(Sum>Max)
        {
            Max=Sum;
            Ans=V[i].c;
        }
    }
    printf("%d\n",Ans);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define MAXV 100001
#define MAXE 200001

typedef struct
{
    int to,next;
} Edge;
Edge E[MAXE];
int Adj[MAXV],Size;

typedef struct
{
    int index,c;
} Value;
Value V[MAXV];
int Res[MAXV],Len;

void Init(int N)
{
    int i;
    for(Size=i=0; i<=N; ++i)
    {
        Adj[i]=-1;
    }
    return;
}

void Add_Edge(int u,int v)
{
    E[Size].to=v;
    E[Size].next=Adj[u];
    Adj[u]=Size++;
    return;
}

void _Add_Edge(int u,int v)
{
    Add_Edge(u,v);
    Add_Edge(v,u);
    return;
}

int cmp(const void *a,const void *b)
{
    return (*(Value *)a).c-(*(Value *)b).c;
}

void Add(int u)
{
    int i;
    for(Len=0,i=Adj[u]; ~i; i=E[i].next)
    {
        Res[Len++]=V[E[i].to].c;
    }
    return;
}

void Find(int u)
{
    int i,j;
    for(i=Adj[u]; ~i; i=E[i].next)
    {
        for(j=0; j<Len; ++j)
        {
            if(Res[j]==V[E[i].to].c)
            {
                break;
            }
        }
        if(j==Len)
        {
            Res[Len++]=V[E[i].to].c;
        }
    }
    return;
}

int main()
{
    int N,M,i,j,Max,Ans,Now;
    scanf("%d %d",&N,&M);
    Init(N);
    for(i=1; i<=N; ++i)
    {
        V[i].index=i;
        scanf("%d",&V[i].c);
    }
    while(M--)
    {
        scanf("%d %d",&i,&j);
        if(V[i].c!=V[j].c)
        {
            _Add_Edge(i,j);
        }
    }
    qsort(V+1,N,sizeof(Value),cmp);
    Max=0;
    Now=1;
    for(i=Now; i<=N; ++i)
    {
        Add(V[i].index);
        for(j=Now+1; j<=N; ++j)
        {
            if(V[j].c!=V[i].c)
            {
                break;
            }
            Find(V[j].index);
        }
        Now=j;
        if(Len>Max)
        {
            Max=Len;
            Ans=V[i].c;
        }
    }
    printf("%d\n",Ans);
    return 0;
}


#include <stdio.h>

#define MAXV 100001

char B[MAXV][MAXV];
int A[MAXV];
int In[MAXV];

int main()
{
    int N,M,i,Max,Ans;
    scanf("%d %d",&N,&M);
    for(i=1;i<=N;++i)
    {
        scanf("%d",&A[i]);
    }
    while(M--)
    {
        scanf("%d %d",&i,&j);
        if(!B[V[i]][V[j]])
        {
            B[V[i]][V[j]]=B[V[j]][V[i]]=1;
            ++In[i];
            ++In[j];
        }
    }
    Max=Ans=0;
    for(i=1;i<=N;++i)
    {
        if(In[i]>Max)
        {
            Max=In[i];
            Ans=V[i];
        }
        else if(In[i]==Max)
        {
            if(V[i]<Ans)
            {
                Ans=V[i];
            }
        }
    }
    printf("%d\n",Ans);
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
struct lis{
    long color;
    struct lis *sgte;
};
typedef struct lis Lista;
void insertar_color(Lista *color[],long color_origen, long color_destino, long colores[],long *men,long *sum);
int main()
{
    Lista *color[100010];
    long colores[100010];
    long usados[100010];
    long n,m,l,k,j,color_destino,color_origen,men,sum,ins,men2;
    scanf("%ld%ld",&n,&m);
    l=1;
    while(l<=n){
        scanf("%ld",&k);
        usados[l]=k;
        colores[k]=1;
        l++;
    }
    men=k;
    l=1;
    sum=1;
    ins=0;
    men2=k;
    while(l<=m){
        scanf("%ld%ld",&k,&j);
        color_origen=usados[k];
        color_destino=usados[j];
        if(color_destino!=color_origen){
                ins++;
            insertar_color(color,color_origen,color_destino,colores,&men,&sum);
           insertar_color(color,color_destino,color_origen,colores,&men,&sum);
        }else{
            if(color_origen<men2){
                men2=color_origen;
            }
            if(color_destino<men2){
                men2=color_destino;
            }
        }

        l++;
    }
    if(ins==0){
        printf("%ld",men2);
    }else{
        printf("%ld",men);
    }
    return 0;
}
void insertar_color(Lista *color[],long color_origen, long color_destino, long colores[],long *men,long *sum){
Lista *recor3,*nuevo;
nuevo=malloc(sizeof(Lista));
           if(color[color_origen]==NULL){
                    colores[color_origen]++;
                    nuevo->color=color_destino;
                    nuevo->sgte=NULL;
                    color[color_origen]=nuevo;
                    if(colores[color_origen]>(*sum)){
                                *men=color_origen;
                                *sum=colores[color_origen];
                    }
                        if(colores[color_origen]==(*sum)){
                            if(color_origen<(*men)){
                                *men=color_origen;
                            }
                        }

           }else{
                recor3=color[color_origen];
                if(recor3->color!=color_destino){
                    while(recor3->color!=color_destino){
                            recor3=recor3->sgte;
                            if(recor3==NULL){
                                break;
                            }
                    }
                    if(recor3==NULL){
                        colores[color_origen]++;
                        nuevo->color=color_destino;
                        nuevo->sgte=color[color_origen];
                        color[color_origen]=nuevo;

                        if(colores[color_origen]>(*sum)){
                                    *men=color_origen;
                                    *sum=colores[color_origen];
                        }
                        if(colores[color_origen]==(*sum)){
                            if(color_origen<(*men)){
                                *men=color_origen;
                            }
                        }
                    }

                }
            }

}


#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<memory.h>
#include<assert.h>
#include<ctype.h>

typedef long long ll;

#define max(a,b) (((a)>(b))?(a):(b))
#define min(a,b) (((a)<(b))?(a):(b))
#define abs(k) (((k)>0)?(k):(-(k)))
int modint(int a,int b) {return(((a)>=0)?((a)-(b)*((a)/(b))):((a)-(b)*((a)/(b)+1)));}
ll modll(ll a,ll b) {return(((a)>=0)?((a)-(b)*((a)/(b))):((a)-(b)*((a)/(b)+1)));}
#define mod(a,b) a=modint(a,b)
#define llmod(a,b) a=modll(a,b)
#define mset(a) memset(a,0,sizeof(a))
#define mcpy(a,b) memcpy(a,b,sizeof(a))
#define inf (1e9)
#define linf (1e18)
#define pi 3.14159265358979323846

void fileio_in_out()
{
     freopen(".in","r",stdin);
     freopen(".out","w",stdout);
}

void fileio_txt()
{
     freopen("input.txt","r",stdin);
     freopen("output.txt","w",stdout);
}

//==================================================

int n,m,sum=0,xx,yy,maxc,ans;
int i,j,k,l;
int a[111111],x[111111],y[111111],b[111111],c[111111];

#define swap(a,b) swapnum(&a,&b)
void swapnum(int *a,int *b)
{
     int t;

     t=*a;
     *a=*b;
     *b=t;
}

int cmp(int a1,int b1,int a2,int b2)
{
    return (a1<a2)||(a1==a2&&b1<b2);
}

void sort(int a[],int b[],int l,int r)
{
    int i,j,mida,midb;

    i=l;
    j=r;
    mida=a[(l+r)/2];
    midb=b[(l+r)/2];
    do{
        while(cmp(a[i],b[i],mida,midb))
          i++;
        while(cmp(mida,midb,a[j],b[j]))
          j--;
        if(i<=j)
          {
            swap(a[i],a[j]);
            swap(b[i],b[j]);
            i++;
            j--;
          }
      }while(i<=j);
    if(i<r)
      sort(a,b,i,r);
    if(j>l)
      sort(a,b,l,j);
}

int main()
{
    //fileio_in_out();
    //fileio_txt();

    mset(b);
    mset(c);

    scanf("%d%d",&n,&m);
    for(i=1;i<=n;i++)
      {
        scanf("%d",&a[i]);
        b[a[i]]=1;
      }
    for(i=1;i<=m;i++)
      {
        scanf("%d%d",&xx,&yy);
        x[i]=a[xx];
        y[i]=a[yy];
        if(x[i]>y[i])
          swap(x[i],y[i]);
      }

    sort(x,y,1,m);
    x[0]=y[0]=0;

    maxc=ans=-1;
    for(i=1;i<=m;i++)
      {
        if(x[i]==y[i]||(x[i]==x[i-1]&&y[i]==y[i-1]))
          continue;
        c[x[i]]++;
        c[y[i]]++;
      }
    /*
    for(i=1;i<111111;i++)
      if(b[i])
        printf("%d %d\n",i,c[i]);*/

    for(i=1;i<111111;i++)
      if(b[i]&&c[i]>maxc)
        {
          maxc=c[i];
          ans=i;
        }

    printf("%d\n",ans);

    //system("pause");
    return 0;
}


#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX 100000;

typedef struct nodoDirectorio{
    long vertice;
    long cardinal;
    struct nodoAdyacente* Lista;
    struct nodoDirectorio* enlace;
} NodoGrafo;

typedef struct nodoAdyacente{
    struct nodoDirectorio* destino;
    struct nodoAdyacente* enlace;
} NodoLista;

int IndexColor(long * color,long n,long bcolor);
void nuevoVertice(NodoGrafo** grafo, long vertice);
NodoGrafo* crearNodoG(long vertice);
void arista(NodoGrafo grafo[101000],const long org, const long dst,long *color);
NodoGrafo* direccion(NodoGrafo* grafo,long vertice);
NodoLista* crearNodoA(NodoGrafo* vertice);
int adyacente(NodoGrafo* grafo,const long org, const long dst);
void imprimirGrafo(NodoGrafo* grafo);
void imprimirAdyacentes(NodoLista* lista);

int main(){
    long n,m;
    NodoGrafo graph[101000];
    scanf("%ld%ld",&n,&m);
    long color[n];
    long i;
    for(i=0;i<n;i++){
        scanf("%ld",&color[i]);
        graph[color[i]]=*crearNodoG(color[i]);
    }
    long f,c;
    for(i=0;i<m;i++){
        scanf("%ld %ld",&f,&c);
       if(color[f-1]!=color[c-1]){
                arista(graph,color[f-1],color[c-1],color);
                arista(graph,color[c-1],color[f-1],color);
       }
    }

    long may = graph[color[0]].cardinal;
    NodoGrafo mayind = graph[color[0]];

    for(i=0;i<n;i++){
        if(graph[color[i]].cardinal>may){
            may = graph[color[i]].cardinal;
            mayind =graph[color[i]];
        }else if(graph[color[i]].cardinal==may){
            if(graph[color[i]].vertice<mayind.vertice){
                may=graph[color[i]].vertice;
                mayind=graph[color[i]];
            }
        }
    }

    printf("%ld",mayind.vertice);

    return 0;
}
int IndexColor(long * color,long n,long bcolor){
    long i;
    for(i=0;i<n;i++){
        if(color[i]==bcolor){
            return i;
        }
    }
    return -1;
}
void nuevoVertice(NodoGrafo** grafo, long vertice){
    NodoGrafo* nuevo;
    NodoGrafo* ptrAnterior;
    NodoGrafo* ptrActual;

    nuevo = crearNodoG(vertice); /* se crea un nuevo nodo*/
    if(nuevo!=NULL){/*si el nodo pudo alojarse en memoria*/
        ptrAnterior = NULL;
        ptrActual = *grafo;

        while(ptrActual!=NULL && vertice >= ptrActual->vertice){
            ptrAnterior = ptrActual;
            ptrActual = ptrActual->enlace;
        }

        if(!ptrAnterior){
            nuevo->enlace = *grafo;
            *grafo = nuevo;
        }else{
            if(vertice != ptrAnterior->vertice){
                ptrAnterior->enlace = nuevo;
                nuevo->enlace = ptrActual;
            }
        }
    }
}
NodoGrafo* crearNodoG(long vertice){
    NodoGrafo* nuevo; /*se crea un nodo nuevo, en el que se inicializan todos sus campos*/
    nuevo=malloc(sizeof(NodoGrafo));
    nuevo->vertice=vertice;
    nuevo->cardinal = 0;
    nuevo->enlace=NULL;
    nuevo->Lista=NULL;
    return nuevo;
}
void arista(NodoGrafo grafo[100000],const long org, const long dst,long *color){
    NodoGrafo* v1,*v2; /* se declaran la variables que contendr�n a los v�rtices*/
    NodoLista* ady; /* se declara el el nuevo arco*/

    v1 = &grafo[org];
    v2 = &grafo[dst]; /* se localiza el nodo destino*/
        /*comprueba la existencia de los v�rtiices */

    int esta = 0;
    if(v1&&v2){
        ady=v1->Lista; /* recorre la lista de adyacencia */
        while(ady){
            if(ady->destino==v2){
                esta=1;
                ady=NULL;   /* para terminar el bucle de busqueda */
            }else{
                ady=ady->enlace;
            }
        }
    }
    if(v1&&v2 && (esta==0)){
        v1->cardinal++;
        ady = crearNodoA(v2); /* se crea el nuevo arco*/
        ady->enlace=v1->Lista; /* y se agrega a la lista de adyacentes al nodo origen*/
        v1 ->Lista = ady;
    }

}
NodoGrafo* direccion(NodoGrafo* grafo,long vertice){
    NodoGrafo* actual;
    actual=grafo;
    while(actual!=NULL){ /*se recorre la lista de nodos*/
        if(actual->vertice == vertice){
            return actual; /*si se encuentra el vertice buscado, se retorna el nodo*/
        }
        actual=actual->enlace;
    }
    return NULL;
}
NodoLista* crearNodoA(NodoGrafo* vertice){
        /* se crea un nuevo arco, se inicializan los campos*/
        NodoLista* nuevo;
        nuevo=malloc(sizeof(NodoLista));
        nuevo->destino=vertice;
        nuevo->enlace=NULL;
        return nuevo;
}
int adyacente(NodoGrafo* grafo,const long org,const long dst){
    NodoGrafo* v1,*v2;
    int esta =0;
    v1 = direccion(grafo,org);
    v2 = direccion(grafo,dst);
    if(v1&&v2){
        NodoLista* ady;
        ady=v1->Lista; /* recorre la lista de adyacencia */
        while(ady){
            if(ady->destino==v2){
                esta=1;
                ady=NULL;   /* para terminar el bucle de busqueda */
            }else{
                ady=ady->enlace;
            }
        }
    }
    return esta;
}