#include <bits/stdc++.h>
using namespace std;

const int N = 100005;

vector<int> adj[N];
int n, m, a[N], id[N];

int f[N], sz[N];
int find(int x) {
    return f[x] == x ? x : f[x] = find(f[x]);
}

// size = 1: cnt1
// size > 1: cnt2
// total dot: tot
// total comp: cnt1 + cnt2
struct Info {
    int cnt1, cnt2, cnt3, tot3;
} pre[N], suf[N];

bool check(Info L, Info R) {
    int solveL = min(L.tot3 - L.cnt3 * 2, R.cnt1);
    L.tot3 -= solveL, R.cnt1 -= solveL;
    int solveR = min(R.tot3 - R.cnt3 * 2, L.cnt1);
    R.tot3 -= solveR, L.cnt1 -= solveR;
    if (L.cnt1 + R.cnt1 > 2) {
        return false;
    }
    int degL = L.cnt1 + 2 * L.cnt2 + L.tot3, cntL = L.cnt1 + L.cnt2 + L.cnt3;
    int degR = R.cnt1 + 2 * R.cnt2 + R.tot3, cntR = R.cnt1 + R.cnt2 + R.cnt3;
    return degL >= cntR && degR >= cntL;
}

int main() {
    // printf("check = %d\n", check({0, 1, 1, 3}, {4, 0, 1, 10000}));
    // return 0;

    scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        id[i] = i;
    }
    sort(id + 1, id + n + 1, [&](int i, int j) { return a[i] < a[j]; });
    static int rk[N];
    for (int i = 1; i <= n; i++)
        rk[id[i]] = i;
    for (int i = 1; i <= m; i++) {
        int u, v;
        scanf("%d%d", &u, &v);
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    for (int i = 1; i <= n; i++) {
        f[i] = i, sz[i] = 1;
    }
    for (int x = 1; x <= n; x++) {
        int u = id[x];
        pre[x] = pre[x - 1];
        pre[x].cnt1++;
        for (auto v : adj[u]) {
            if (rk[v] >= rk[u])
                continue;
            if (find(u) == find(v))
                continue;
            int fu = find(u), fv = find(v);
            pre[x].cnt1 -= (sz[fu] == 1) + (sz[fv] == 1);
            pre[x].cnt2 -= (sz[fu] == 2) + (sz[fv] == 2);
            pre[x].cnt3 -= (sz[fu] >= 3) + (sz[fv] >= 3);
            pre[x].tot3 -=
                (sz[fu] >= 3 ? sz[fu] : 0) + (sz[fv] >= 3 ? sz[fv] : 0);
            sz[fv] += sz[fu], f[fu] = fv;
            pre[x].cnt1 += (sz[fv] == 1);
            pre[x].cnt2 += (sz[fv] == 2);
            pre[x].cnt3 += (sz[fv] >= 3);
            pre[x].tot3 += (sz[fv] >= 3 ? sz[fv] : 0);
        }
    }
    for (int i = 1; i <= n; i++) {
        f[i] = i, sz[i] = 1;
    }
    for (int x = n; x >= 1; x--) {
        int u = id[x];
        suf[x] = suf[x + 1];
        suf[x].cnt1++;
        for (auto v : adj[u]) {
            if (rk[v] <= rk[u])
                continue;
            if (find(u) == find(v))
                continue;
            int fu = find(u), fv = find(v);
            suf[x].cnt1 -= (sz[fu] == 1) + (sz[fv] == 1);
            suf[x].cnt2 -= (sz[fu] == 2) + (sz[fv] == 2);
            suf[x].cnt3 -= (sz[fu] >= 3) + (sz[fv] >= 3);
            suf[x].tot3 -=
                (sz[fu] >= 3 ? sz[fu] : 0) + (sz[fv] >= 3 ? sz[fv] : 0);
            sz[fv] += sz[fu], f[fu] = fv;
            suf[x].cnt1 += (sz[fv] == 1);
            suf[x].cnt2 += (sz[fv] == 2);
            suf[x].cnt3 += (sz[fv] >= 3);
            suf[x].tot3 += (sz[fv] >= 3 ? sz[fv] : 0);
        }
    }

    for (int x = 1; x < n; x++) {
        if (a[id[x]] != a[id[x + 1]]) {
            //            printf("current debug %d\n", a[id[x]]);
            if (check(pre[x], suf[x + 1])) {
                printf("%d\n", a[id[x]]);
                return 0;
            }
        }
    }
    puts("-1");
    return 0;
}