9 5 14
7 1 4 8 5 2 6 9 3
2 8
1 6
5 7
1 3
3 9
1 5
1 8
1 5
1 4
1 8
1 3
1 5
1 5
1 7
1 7
2 3
1 2
1 1
1 2
 6 5 8
1 2 6 3 4 5
2 4
1 3
1 6
3 5
2 5
1 1
1 4
1 1
2 1
2 5
2 2
2 3
1 4
 2 1 3
1 2
1 2
1 1
1 1
1 1

6
9
5
8
1
7
0
0
0
0
0
4
0
 6
5
4
3
 2
1
0

#include <bits/stdc++.h>
using namespace std;
const int max_n = 400005;
vector<int> grafai[max_n];
bool vyriausias[max_n];
pair<int, int> vaikai[max_n];
int DSU[max_n];
int paskutinis;
void init_search(int n) {
  paskutinis = n + 1;
  for (int i = 1; i < max_n; i++) {
    DSU[i] = i;
  }
  for (int i = 1; i <= n; i++) {
    grafai[i].push_back(i);
    vyriausias[i] = true;
  }
}
int tevas(int id) {
  if (id == DSU[id])
    return id;
  else
    return DSU[id] = tevas(DSU[id]);
}
void merge(int i, int j) {
  int itevas = tevas(i), jtevas = tevas(j);
  if (itevas != jtevas) {
    paskutinis++;
    vyriausias[itevas] = false;
    vyriausias[jtevas] = false;
    vyriausias[paskutinis] = true;
    for (int x = 0; x < grafai[itevas].size(); x++) {
      grafai[paskutinis].push_back(grafai[itevas][x]);
    }
    for (int x = 0; x < grafai[jtevas].size(); x++) {
      grafai[paskutinis].push_back(grafai[jtevas][x]);
    }
    DSU[itevas] = paskutinis;
    DSU[jtevas] = paskutinis;
    vaikai[paskutinis] = {itevas, jtevas};
  }
}
struct node {
  node *left, *right;
  int verte, didziausio_indeksas;
  int pradzia, pabaiga;
  node(int pr, int pb, int p_gal[]) {
    pradzia = pr;
    pabaiga = pb;
    if (pr == pb) {
      left = NULL;
      right = NULL;
      verte = p_gal[pr];
      didziausio_indeksas = pr;
    } else {
      left = new node(pr, (pr + pb) / 2, p_gal);
      right = new node((pr + pb) / 2 + 1, pb, p_gal);
      if (left->verte >= right->verte) {
        didziausio_indeksas = left->didziausio_indeksas;
        verte = left->verte;
      } else {
        didziausio_indeksas = right->didziausio_indeksas;
        verte = right->verte;
      }
    }
  }
  void set(int id, int new_value) {
    if ((pradzia == pabaiga) && (pradzia == id)) {
      verte = new_value;
      didziausio_indeksas = id;
      return;
    } else if (id <= left->pabaiga)
      left->set(id, new_value);
    else
      right->set(id, new_value);
    if (left->verte >= right->verte)
      didziausio_indeksas = left->didziausio_indeksas;
    else
      didziausio_indeksas = right->didziausio_indeksas;
    verte = max(left->verte, right->verte);
  }
  int get(int id) {
    if ((pradzia == pabaiga) && (pradzia == id))
      return verte;
    else if (id <= left->pabaiga)
      left->get(id);
    else
      right->get(id);
  }
  pair<int, int> get_didziausio_indeksa(int pr, int pb) {
    if ((pb < pradzia) || (pabaiga < pr))
      return {-1, -1};
    else if ((pr <= pradzia) && (pabaiga <= pb)) {
      return {didziausio_indeksas, verte};
    } else {
      pair<int, int> kaire = left->get_didziausio_indeksa(pr, pb);
      pair<int, int> desine = right->get_didziausio_indeksa(pr, pb);
      if (kaire.second >= desine.second)
        return kaire;
      else
        return desine;
    }
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(NULL);
  cout.tie(NULL);
  int n, m, q;
  cin >> n >> m >> q;
  init_search(n);
  int p[n];
  for (int i = 0; i < n; i++) cin >> p[i];
  pair<int, int> briaunos[m + 1];
  for (int i = 1; i <= m; i++) {
    int a, b;
    cin >> a >> b;
    briaunos[i] = {a, b};
  }
  pair<int, int> uzklausos[q + 1];
  for (int i = 0; i < q; i++) {
    int tipas;
    int skaicius;
    cin >> tipas >> skaicius;
    uzklausos[i] = {tipas, skaicius};
  }
  int isimtos[m + 1];
  for (int i = 0; i < q; i++) {
    if (uzklausos[i].first == 2) {
      isimtos[uzklausos[i].second] = true;
    }
  }
  for (int i = 1; i <= m; i++) {
    if (!isimtos[i]) merge(briaunos[i].first, briaunos[i].second);
  }
  vector<pair<int, int> > grafo_dalinimai;
  for (int i = q - 1; i >= 0; i--) {
    if (uzklausos[i].first == 2) {
      merge(briaunos[uzklausos[i].second].first,
            briaunos[uzklausos[i].second].second);
      grafo_dalinimai.push_back({i, paskutinis});
    }
  }
  reverse(grafo_dalinimai.begin(), grafo_dalinimai.end());
  vector<int> galinis;
  set<int> skirtukai;
  skirtukai.insert(0);
  skirtukai.insert(n);
  for (int i = 1; i <= paskutinis; i++) {
    if (vyriausias[i]) {
      for (int j = 0; j < grafai[i].size(); j++)
        galinis.push_back(grafai[i][j]);
      skirtukai.insert(galinis.size());
    }
  }
  int pozicija_galiniame[galinis.size() + 1];
  for (int i = 0; i < galinis.size(); i++) {
    pozicija_galiniame[galinis[i]] = i + 1;
  }
  int p_gal[galinis.size() + 1];
  for (int i = 0; i < galinis.size(); i++) {
    p_gal[pozicija_galiniame[i + 1]] = p[i];
  }
  node medis(1, n, p_gal);
  int busimas_padalijimas = 0;
  for (int i = 0; i < q; i++) {
    if (uzklausos[i].first == 1) {
      int pradzia, pabaiga;
      int poz = pozicija_galiniame[uzklausos[i].second];
      set<int>::iterator it = skirtukai.lower_bound(poz);
      pabaiga = *it;
      it--;
      pradzia = *it;
      pradzia++;
      pair<int, int> ats = medis.get_didziausio_indeksa(pradzia, pabaiga);
      cout << ats.second << "\n";
      medis.set(ats.first, 0);
    } else {
      if ((busimas_padalijimas < grafo_dalinimai.size()) &&
          (grafo_dalinimai[busimas_padalijimas].first == i)) {
        int grafo_numeris = grafo_dalinimai[busimas_padalijimas].second;
        int pirma_virsune = grafai[grafo_numeris][0];
        int grafo_dydis = grafai[grafo_numeris].size();
        int virsunes_pozicija = pozicija_galiniame[pirma_virsune];
        skirtukai.insert(virsunes_pozicija + grafo_dydis - 1);
        busimas_padalijimas++;
      }
    }
  }
  return 0;
}
