You've got an undirected graph, consisting of *n* vertices and *m* edges. We will consider the graph's vertices numbered with integers from 1 to *n*. Each vertex of the graph has a color. The color of the *i*-th vertex is an integer *c*<sub class="lower-index">*i*</sub>.

Let's consider all vertices of the graph, that are painted some color *k*. Let's denote a set of such as *V*(*k*). Let's denote the value of the neighbouring color diversity for color *k* as the cardinality of the set *Q*(*k*) = {*c*<sub class="lower-index">*u*</sub> :  *c*<sub class="lower-index">*u*</sub> ≠ *k* and there is vertex *v* belonging to set *V*(*k*) such that nodes *v* and *u* are connected by an edge of the graph}.

Your task is to find such color *k*, which makes the cardinality of set *Q*(*k*) maximum. In other words, you want to find the color that has the most diverse neighbours. Please note, that you want to find such color *k*, that the graph has at least one vertex with such color.
The first line contains two space-separated integers *n*, *m* (1 ≤ *n*, *m* ≤ 10<sup class="upper-index">5</sup>) — the number of vertices end edges of the graph, correspondingly. The second line contains a sequence of integers *c*<sub class="lower-index">1</sub>, *c*<sub class="lower-index">2</sub>, ..., *c*<sub class="lower-index">*n*</sub> (1 ≤ *c*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">5</sup>) — the colors of the graph vertices. The numbers on the line are separated by spaces.

Next *m* lines contain the description of the edges: the *i*-th line contains two space-separated integers *a*<sub class="lower-index">*i*</sub>, *b*<sub class="lower-index">*i*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub>, *b*<sub class="lower-index">*i*</sub> ≤ *n*; *a*<sub class="lower-index">*i*</sub> ≠ *b*<sub class="lower-index">*i*</sub>) — the numbers of the vertices, connected by the *i*-th edge. 

It is guaranteed that the given graph has no self-loops or multiple edges.
from sys import stdin,stdout
input = stdin.readline
from queue import Queue
def bfs(graph,visited,queue,ans,c):
    while not(queue.empty()):
        a = queue.get()
        visited[a] = True
        for h in graph[a]:
            if h not in visited.keys():
                visited[h] = True
                queue.put(h)
            if c[a-1] != c[h-1]:
                ans[c[a-1]].add(c[h-1])
                ans[c[h-1]].add(c[a-1])
n,m = map(int,input().split())
c = list(map(int,input().split()))
graph = {}
visited = {}
queue = Queue()
ans = {}
for j in range(n):
    ans[c[j]] = set()
for i in range(m): 
    a,b = map(int,input().split())
    if a in graph.keys():
        graph[a].append(b)
    else:
        graph[a] = [b]
    if b in graph.keys():
        graph[b].append(a)
    else:
        graph[b] = [a]
for p in range(1,n+1):
    if p not in visited.keys():
        queue.put(p)
        bfs(graph,visited,queue,ans,c)
# print(ans)
max1 = 0
store = None
for h in ans.keys():
    if len(ans[h]) > max1:
        store = h
        max1 = len(ans[h])
print(store)

