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.
import sys
import os.path
 
if(os.path.exists('input.txt')) :
    sys.stdin = open("input.txt", "r")
    sys.stdout = open("output.txt", "w")
    sys.stderr = open("error.txt", "w")
    
depth = 1000000
mod = 1000000007 
lim = mod * mod
sys.setrecursionlimit(depth) 
 
linp = lambda: list(minp())
minp = lambda: map(int, input().split())
 
from math import inf, ceil, sqrt, log2, gcd
from collections import defaultdict, deque
 
dd = lambda x: defaultdict(lambda: x)
dxy = [(1, 0),(-1, 0),(0, 1),(0, -1)]

(n, m), c = minp(), [0] + linp()
adj = [[] for _ in range(n+1)]
for _ in range(m) :
    u, v = minp()
    adj[u].append(v)
    adj[v].append(u) 
d = defaultdict(lambda:[])
for i in range(1, n+1) :
    d[c[i]].append(i)
d = sorted(list(d.items()), key=lambda x: x[0]) 
val, ans = 0, 0
for x, y in d :
    s = set()
    for e in y :
        for v in adj[e] :
            if c[v] != x :
                s.add(c[v])
    if val < len(s) :
        val, ans = len(s), x
print(ans)