//thanks BeyondHeaven 
#include <bits/stdc++.h>
constexpr int P = 998244353;
struct mint {
  public:
  	mint(int x = 0): v(x % P) { v += ((v >> 31) & P); }
  	int val() const { return v; }
  	
  	mint &operator += (const mint &rhs) { v += rhs.v - P; v += ((v >> 31) & P); return *this; }
  	mint &operator -= (const mint &rhs) { v -= rhs.v; v += ((v >> 31) & P); return *this; }
  	mint &operator *= (const mint &rhs) { v = (unsigned long long)(v) * rhs.v % P; return *this; }
  	mint &operator /= (const mint &rhs) { return *this *= rhs.inv(); }
  	
	mint operator - () const { return mint(-v); }

  	bool operator == (const mint &rhs) const { return v == rhs.v; }
    bool operator != (const mint &rhs) const { return v != rhs.v; } 
  	
  	friend mint operator + (mint lhs, const mint &rhs) { return lhs += rhs; }
  	friend mint operator - (mint lhs, const mint &rhs) { return lhs -= rhs; }
  	friend mint operator * (mint lhs, const mint &rhs) { return lhs *= rhs; }
  	friend mint operator / (mint lhs, const mint &rhs) { return lhs /= rhs; }

  	friend std::istream &operator >> (std::istream &is, mint &m) { return is >> m.v; }
	friend std::ostream &operator << (std::ostream &os, const mint &m) { return os << m.v; }
  	
  	mint inv() const;
  	
  	mint pow(int n) const {
  		mint x = *this, r = 1;
  		for (; n; n >>= 1, x *= x) {
  			if (n & 1) {
  				r *= x;
			}
		}
		return r;
	}
  private:
  	int v;
};

struct _simple {
  public:
	friend struct mint;
	_simple() { init(1); }
	
	mint fac(int n) const { return _fac[n]; }
	mint ifac(int n) const { return _ifac[n]; }
	mint inv(int n)	const { return _inv[n]; }
	mint binom(int n, int m) const {
		if (m < 0 || m > n) {
			return 0;
		} else {
			return _fac[n] * _ifac[m] * _ifac[n - m];
		}
	}
	
	void init(int n) {
		_n = n;
		_fac.resize(n + 1), _ifac.resize(n + 1), _inv.resize(n + 1);
		
		_fac[0] = 1;
		for (int i = 1; i <= n; i++) {
			_fac[i] = _fac[i - 1] * i;
		}
		
		_ifac[n] = _fac[n].pow(P - 2);
		for (int i = n; i >= 1; i--) {
			_ifac[i - 1] = _ifac[i] * i;
		}
		
		for (int i = 1; i <= n; i++) {
			_inv[i] = _ifac[i] * _fac[i - 1];
		}
	}
  private:
  	int _n;
  	std::vector<mint> _fac, _ifac, _inv;
} simple;

mint mint::inv() const {
	if (v <= simple._n) {
		return simple.inv(v);
	} else {
		return pow(P - 2);
	}
}

using namespace std;

int main() {
	ios::sync_with_stdio(0); cin.tie(0);
	int n, m;
	cin >> n >> m;
	simple.init(1919810);
	vector<int> a(n);
	for (int &x : a) {
		cin >> x;
	}
	auto x = a;
	sort(x.begin(), x.end());
	vector<vector<pair<int, int>>> el(n), er(n);
	while (m--) {
		int l, r;
		cin >> l >> r;
		if (a[--l] > a[--r]) {
			swap(l, r);
		}
		el[upper_bound(x.begin(), x.end(), a[l]) - x.begin() - 1].emplace_back(l, r);
		er[upper_bound(x.begin(), x.end(), a[r]) - x.begin() - 1].emplace_back(l, r);
	}
	vector<int> repr(n), num(n);
	function<int(int)> root = [&](int i) {
		return repr[i] < 0 ? i : repr[i] = root(repr[i]);
	};
	auto merge = [&](int i, int j) {
		i = root(i), j = root(j);
		if (i == j) return 0;
		repr[j] = i;
		return 1;
	};
	int cnt = 0;
	fill(repr.begin(), repr.end(), -1);
	for (int i = 0; i < n; i++) {
		num[n - i - 1] = cnt;
		for (auto [l, r] : el[n - i - 1]) {
			cnt += merge(l, r);
		}
	}
	cnt = 0;
	fill(repr.begin(), repr.end(), -1);
	for (int i = 0; i < n - 1; i++) {
		if (x[i] != x[i + 1]) {
			for (auto [l, r] : er[i]) {
				cnt += merge(l, r);
			}
			if (min(i + 1, n - i - 1) >= n - num[i] - cnt - 1) {
				cout << x[i] << '\n';
				return 0;
			}
		}
	}
	cout << "-1\n";
	return 0;
}