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

//<------------------------------FOR USING PBDS------------------------------->
#include <ext/pb_ds/assoc_container.hpp> // Common file
#include <ext/pb_ds/tree_policy.hpp>
#include <functional> // for less
#include <iostream>
using namespace __gnu_pbds;

template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
//ordered_multiset<int> s;

//Declaring ordered_set
typedef tree<int, null_type, less<int>, rb_tree_tag,
      tree_order_statistics_node_update>
  ordered_set;

ordered_set s;

//<-------------------------------PBDS ENDS HERE----------------------------->


//#pragma GCC optimize "trapv"
#define loop(i,j,k,in)              for(int i=j; i<k; i+=in)
#define rloop(i,j,k,in)             for(int i=j; i>=k; i-=in)
#define mem(a,b)                    memset(a, b, sizeof(a))
#define mod                         1000000007
#define pub                         push_back
#define pob                         pop_back
#define endl                        "\n"

typedef pair<int,int>               pii;
typedef vector<int>                 vi;
typedef vector<char>                vc;
typedef vector<string>              vs;
typedef vector<pii>                 vii;
typedef map<int,int>                mii;
typedef set<int>                    si;
typedef long long int               ll;
typedef unsigned long long int      ull;

int dp[200005];
bool vis[200005];


void dfs(int node, vector<vector<ll>> &adj)
{
    vis[node] = true;
 
    for (int i = 0; i < adj[node].size(); i++) {
         if (!vis[adj[node][i]])
            dfs(adj[node][i], adj);
 
        dp[node] = max(dp[node], 1 + dp[adj[node][i]]);
    }
}
int findLongestPath(vector<vector<ll>> &adj, int n, int mid , vector<ll> &arr)
{

    memset(dp, 0, sizeof(dp));

    memset(vis, false, sizeof(vis));
     for (int i = 0; i < n; i++) {
        if (!vis[i])
            dfs(i, adj);
    }
 
    int ans = -1;
     for (int i = 0; i < n; i++) {
        if(arr[i] > mid) continue;
        ans = max(ans, dp[i]);
    }
    return ans;
}

bool check(ll x, vector<vector<int>> &edges, vector<ll> &arr, long long k){
  int n = arr.size();
  vector<ll> indeg(n , 0);
  vector<vector<ll>> adj(n);
  for(auto &e : edges){
    if(arr[e[0]] <= x && arr[e[1]]<=x){
      adj[e[0]].push_back(e[1]);
      indeg[e[1]]++;
    }
  }


  vector<ll> topo;
  queue<ll> que;
  for(int i=0; i<n; i++){
    if(indeg[i] == 0 && arr[i] <= x) que.push(i);
  }
  while(!que.empty()){
    auto node = que.front();
    que.pop();
    topo.push_back(node);
    for(auto &it : adj[node]){
      indeg[it]--;
      if(indeg[it] == 0) que.push(it);
    }
  }

  bool f = false;
  for(int i=0; i<n; i++){
    if(indeg[i] > 0) f = true;
  }
  if(f) return true;
  int maxdis;
  maxdis = findLongestPath(adj, n, x, arr);
  if(maxdis >= k-1) return true;
  return false;


}


int main(){
  ios::sync_with_stdio(false);
    cin.tie(0);
  #ifndef ONLINE_JUDGE
  freopen("input.txt","r",stdin);
  freopen("output.txt","w",stdout);
  #endif
  int t;
  // cin>>t;
  t = 1;
  while(t--){
    ll n,m,k;
    cin>>n>>m>>k;
    vector<ll> arr(n);
    for(auto &it: arr) cin>>it;
    vector<vector<int>> edges;
    for(int i=0; i<m; i++){
      int u,v;
      cin>>u>>v;
      u--,v--;
      edges.push_back({u,v});
    }
    ll lo = 1 , hi = *max_element(arr.begin(), arr.end());
    ll ans = -1;
    while(lo <= hi){
      ll mid = (lo + (hi - lo)/2);
      if(check(mid, edges, arr, k)){
        ans= mid;
        hi = mid-1;
      }else{
        lo = mid+1;
      }
    }
    cout<<ans<<endl;
  }
  
  
  return 0;
}