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>
namespace mem {
namespace stdval {
using i32 = int;
using i64 = long long;
using u32 = unsigned int;
using u64 = unsigned long long;
using f32 = float;
using f64 = double;
using i128 = __int128_t;
using u128 = __uint128_t;
}  // namespace stdval
namespace utils {
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
using std::function;
using std::lower_bound;
using std::make_pair;
using std::make_tuple;
using std::max_element;
using std::min_element;
using std::reverse;
using std::shuffle;
using std::sort;
using std::swap;
using std::tie;
using std::upper_bound;
}  // namespace utils
namespace io {
namespace fastio {
const int BUFFER = 1 << 21;
char ibuf[BUFFER], *iS, *iT;
inline int getc() {
  if (iS == iT) {
    iT = (iS = ibuf) + fread(ibuf, 1, BUFFER, stdin);
    return iS == iT ? EOF : *iS++;
  } else {
    return *iS++;
  }
}
char obuf[BUFFER], *oS = obuf, *oT = oS + BUFFER - 1;
inline void flush() {
  fwrite(obuf, 1, oS - obuf, stdout);
  oS = obuf;
}
inline void putc(int x) {
  *oS++ = x;
  if (oS == oT) flush();
}
struct Flusher {
  ~Flusher() { flush(); }
} flusher;
}  // namespace fastio
using fastio::getc;
using fastio::putc;
template <class T>
inline void readDigit(T &x) {
  x = getc();
  while (!isdigit(x)) x = getc();
}
inline int readDigit() {
  int x;
  readDigit(x);
  return x;
}
template <class T>
inline void readAlpha(T &x) {
  x = getc();
  while (!isalpha(x)) x = getc();
}
inline int readAlpha() {
  int x;
  readAlpha(x);
  return x;
}
template <class T>
inline void readInt(T &x) {
  x = 0;
  bool f = 0;
  char c = getc();
  while (!isdigit(c)) f ^= c == '-', c = getc();
  while (isdigit(c)) x = x * 10 + c - '0', c = getc();
  if (f) x = -x;
}
inline void read(int &x) {
  x = 0;
  bool f = 0;
  char c = getc();
  while (!isdigit(c)) f ^= c == '-', c = getc();
  while (isdigit(c)) x = x * 10 + c - '0', c = getc();
  if (f) x = -x;
}
inline void read(unsigned int &x) {
  x = 0;
  bool f = 0;
  char c = getc();
  while (!isdigit(c)) f ^= c == '-', c = getc();
  while (isdigit(c)) x = x * 10 + c - '0', c = getc();
  if (f) x = -x;
}
inline void read(long long &x) {
  x = 0;
  bool f = 0;
  char c = getc();
  while (!isdigit(c)) f ^= c == '-', c = getc();
  while (isdigit(c)) x = x * 10 + c - '0', c = getc();
  if (f) x = -x;
}
inline void read(unsigned long long &x) {
  x = 0;
  bool f = 0;
  char c = getc();
  while (!isdigit(c)) f ^= c == '-', c = getc();
  while (isdigit(c)) x = x * 10 + c - '0', c = getc();
  if (f) x = -x;
}
inline void read(char &x) { x = getc(); }
template <class T = int>
inline T read() {
  T x;
  read(x);
  return x;
}
template <class T, class... Args>
inline void read(T &x, Args &...args) {
  read(x), read(args...);
}
inline void print(int x) {
  if (x < 0) putc('-'), x = -x;
  if (x > 9) print(x / 10);
  putc('0' + x % 10);
}
inline void print(unsigned int x) {
  if (x < 0) putc('-'), x = -x;
  if (x > 9) print(x / 10);
  putc('0' + x % 10);
}
inline void print(long long x) {
  if (x < 0) putc('-'), x = -x;
  if (x > 9) print(x / 10);
  putc('0' + x % 10);
}
inline void print(unsigned long long x) {
  if (x < 0) putc('-'), x = -x;
  if (x > 9) print(x / 10);
  putc('0' + x % 10);
}
inline void print(char x) { putc(x); }
inline void print(const char *s) {
  int len = strlen(s);
  for (int i = 0; i < len; i++) putc(s[i]);
}
inline void print(const std::string &s) {
  for (int i = 0; i < s.length(); i++) putc(s[i]);
}
template <class T, class... Args>
inline void print(const T &x, Args... args) {
  print(x), print(args...);
}
template <class... Args>
inline void println(Args... args) {
  print(args...), putchar('\n');
}
}  // namespace io
namespace random {
const int LuckyNumber = 20040725;
std::mt19937 rng(LuckyNumber ^
                 std::chrono::steady_clock::now().time_since_epoch().count());
std::mt19937_64 rng64(
    LuckyNumber ^ std::chrono::steady_clock::now().time_since_epoch().count());
template <class T>
inline T rand(T l, T r) {
  return std::uniform_int_distribution<T>(l, r)(rng);
}
template <class T>
inline T rand64(T l, T r) {
  return std::uniform_int_distribution<T>(l, r)(rng);
}
}  // namespace random
namespace modint {
template <const int mod>
struct Z {
  int x;
  inline Z() { x = 0; }
  inline Z(int t) { x = t; }
  inline void operator-=(Z a) { (x -= a.x) < 0 && (x += mod); }
  inline void operator+=(Z a) { (x += a.x) >= mod && (x -= mod); }
  inline void operator*=(Z a) { x = (long long)x * a.x % mod; }
  friend inline Z operator*(Z a, Z b) { return (long long)a.x * b.x % mod; }
  friend inline Z operator-(Z a, Z b) {
    return ((a.x -= b.x) < 0 && (a.x += mod)), a;
  }
  friend inline Z operator+(Z a, Z b) {
    return ((a.x += b.x) >= mod && (a.x -= mod)), a;
  }
};
template <const int mod>
inline Z<mod> finv(Z<mod> x) {
  if (x.x < 2) return x;
  return (mod - mod / x.x) * finv(mod % x.x);
}
template <const int mod>
inline Z<mod> fpow(Z<mod> a, int b) {
  Z<mod> s = 1;
  for (; b; b >>= 1, a = a * a)
    if (b & 1) s = s * a;
  return s;
}
template <const int mod>
inline void init_inverse(int n, Z<mod> *inv) {
  inv[0] = inv[1] = 1;
  for (int i = 2; i < n; i++) inv[i] = (mod - mod / i) * inv[mod % i];
}
template <const int mod>
inline void init_factorial(int n, Z<mod> *fac, Z<mod> *ifac) {
  fac[0] = 1, init_inverse(n, ifac);
  for (int i = 1; i < n; i++)
    fac[i] = fac[i - 1] * i, ifac[i] = ifac[i - 1] * ifac[i];
}
}  // namespace modint
namespace math {
using std::max;
using std::min;
template <class T>
inline T abs(T x) {
  return x < 0 ? -x : x;
}
template <class T>
inline T gcd(T n, T m) {
  return m ? gcd(m, n % m) : n;
}
template <class T>
inline T lcm(T n, T m) {
  return n / gcd(n, m) * m;
}
template <const stdval::u64 p>
struct FastDiv {
  stdval::u64 t, i;
  inline FastDiv() : t(stdval::u64(-1) / p), i(mul_inv(p)) {}
  inline bool divide(stdval::u64 n) { return n * i <= t; }
  inline bool divide(stdval::i64 n) {
    return stdval::u64(n < 0 ? -n : n) * i <= t;
  }
  inline stdval::u64 mul_inv(stdval::u64 n) {
    stdval::u64 x = n;
    for (int i = 0; i < 5; ++i) x *= 2 - n * x;
    return x;
  }
};
template <const stdval::u64 b>
struct FastMod {
  stdval::u64 m;
  inline FastMod() : m(stdval::u64((stdval::u128(1) << 64) / b)) {}
  inline stdval::u64 reduce(stdval::u64 a) {
    stdval::u64 q = (stdval::u64)((stdval::u128(m) * a) >> 64);
    stdval::u64 r = a - q * b;
    return r >= b ? r - b : r;
  }
};
}  // namespace math
namespace container {
using std::map;
using std::pair;
using std::set;
using std::tuple;
using std::unordered_map;
using std::unordered_set;
template <class T>
struct vector : std::vector<T> {
  using std::vector<T>::vector;
  vector() : std::vector<T>() {}
  vector(const std::vector<T> &plain) : std::vector<T>(plain) {}
  inline void read(int s = -1) {
    if (~s) this->resize(s);
    for (size_t i = 0; i < this->size(); i++) {
      io::read(this->operator[](i));
    }
  }
  inline void print(char pt0 = ' ', char pt1 = '\n') {
    for (size_t i = 0; i < this->size(); i++) {
      io::print(this->operator[](i));
      if (i + 1 < this->size()) io::putc(pt0);
    }
    io::putc(pt1);
  }
  inline void sort() { std::sort(this->begin(), this->end()); }
  inline void concat(const vector &rhs) {
    this->insert(this->end(), rhs.begin(), rhs.end());
  }
  inline bool includes(const T &x) const {
    return std::find(this->begin(), this->end(), x) != this->end();
  }
  inline vector slice(int l, int r) const {
    if (l > r) return {};
    if (r < this->size()) return vector(this->begin() + l, this->begin() + r);
    vector<int> rsp = (this->begin() + l, this->end());
    return rsp.resize(r - l), rsp;
  }
  inline void from(const std::set<T> &src) {
    this->resize(src.size());
    auto it = this->begin();
    for (const T e : src) *it++ = e;
  }
  template <class Function>
  inline void forEach(Function func) {
    for (const auto &it : *this) func(it);
  }
  template <class R, class Function>
  inline vector<R> _map(Function func) const {
    vector<R> res(this->size());
    for (size_t i = 0; i < this->size(); i++)
      res[i] = func(this->operator[](i));
    return res;
  }
  template <class R>
  inline vector<R> map(R func(T)) const {
    return this->_map<R>(func);
  }
  template <class R>
  inline vector<R> map(const std::function<R(T)> &func) const {
    return this->_map<R>(func);
  }
};
}  // namespace container
namespace str {
using namespace mem::container;
struct string : std::string {
  using std::string::string;
  string() : std::string("") {}
  string(const std::string &plain) : std::string(plain) {}
  inline string join(const vector<string> &) const;
  inline string join(const std::vector<string> &) const;
  template <class T>
  inline string join(const vector<T> &) const;
  template <class T>
  inline string join(const std::vector<T> &) const;
  vector<string> split(const string &delim) const {
    if (this->empty()) return {};
    char *src = new char[this->length() + 1];
    strcpy(src, this->c_str());
    char *tar = new char[delim.length() + 1];
    strcpy(tar, delim.c_str());
    vector<string> rsp;
    for (char *pos = strtok(src, tar); pos; pos = strtok(nullptr, tar))
      rsp.push_back(string(pos));
    delete[] src;
    delete[] tar;
    return rsp;
  }
  template <class... Args>
  static inline string format(const char *fm, Args... args) {
    int len = snprintf(nullptr, 0, fm, args...);
    char *buf = new char[len + 1];
    snprintf(buf, len + 1, fm, args...);
    string str(buf);
    delete[] buf;
    return str;
  }
  template <class... Args>
  static inline string format(const string &fm, Args... args) {
    return format(fm.c_str(), args...);
  }
};
inline string to_string(const float &x) { return std::to_string(x); }
inline string to_string(const double &x) { return std::to_string(x); }
inline string to_string(const int &x) { return std::to_string(x); }
inline string to_string(const unsigned int &x) { return std::to_string(x); }
inline string to_string(const long long &x) { return std::to_string(x); }
inline string to_string(const unsigned long long &x) {
  return std::to_string(x);
}
template <class T>
inline string to_string(const vector<T> &vet) {
  return "{" + string(",").join(vet) + "}";
}
template <class T>
inline string to_string(const std::vector<T> &vet) {
  return to_string(vector<T>(vet.begin(), vet.end()));
}
template <const int mod>
inline string to_string(const mem::modint::Z<mod> &zval) {
  return std::to_string(zval.x);
}
inline string string::join(const vector<string> &vet) const {
  if (!vet.size()) return "";
  string res = string(vet[0]);
  for (size_t i = 1; i < vet.size(); i++) {
    res += *this;
    res += string(vet[i]);
  }
  return res;
}
inline string string::join(const std::vector<string> &vet) const {
  if (!vet.size()) return "";
  string res = string(vet[0]);
  for (size_t i = 1; i < vet.size(); i++) {
    res += *this;
    res += string(vet[i]);
  }
  return res;
}
template <class T>
inline string string::join(const vector<T> &vet) const {
  if (!vet.size()) return "";
  string res = to_string(vet[0]);
  for (size_t i = 1; i < vet.size(); i++) {
    res += *this;
    res += to_string(vet[i]);
  }
  return res;
}
template <class T>
inline string string::join(const std::vector<T> &vet) const {
  if (!vet.size()) return "";
  string res = to_string(vet[0]);
  for (size_t i = 1; i < vet.size(); i++) {
    res += *this;
    res += to_string(vet[i]);
  }
  return res;
}
inline void print(const str::string &s) {
  for (size_t i = 0; i < s.length(); i++) mem::io::putc(s[i]);
}
template <class... Args>
inline void printfm(const char *fm, Args... args) {
  print(str::string().format(fm, args...));
}
template <class... Args>
inline void printfm(const string &fm, Args... args) {
  print(str::string().format(fm, args...));
}
template <class... Args>
inline void printfm(const std::string &fm, Args... args) {
  print(str::string().format(fm, args...));
}
}  // namespace str
using namespace io;
using namespace str;
using namespace math;
using namespace utils;
using namespace modint;
using namespace random;
using namespace stdval;
using namespace container;
}  // namespace mem
const int N = 5e5 + 10;
using namespace mem::io;
using namespace mem::container;
int n, m, q, p[N], anc[N];
bool mrk[N], vis[N];
vector<int> ele[N];
pair<vector<int>, int> dat[N];
struct cmp {
 public:
  inline bool operator()(const int x, const int y) { return p[x] < p[y]; }
};
std::priority_queue<int, std::vector<int>, cmp> f[N], g[N];
struct Edge {
  int u, v;
} e[N];
struct Query {
  int o, x;
} y[N];
int find(int x) {
  if (x == anc[x]) return x;
  return find(anc[x]);
}
int pop(int k) {
  while (f[k].size() && g[k].size()) {
    if (f[k].top() == g[k].top()) {
      f[k].pop(), g[k].pop();
    } else {
      int x = f[k].top();
      f[k].pop();
      return x;
    }
  }
  if (f[k].size()) {
    int x = f[k].top();
    f[k].pop();
    return x;
  } else {
    return 0;
  }
}
pair<vector<int>, int> merge(int u, int v) {
  u = find(u), v = find(v);
  if (u == v) return {{}, -1};
  if (ele[u].size() > ele[v].size()) std::swap(u, v);
  ele[v].insert(ele[v].end(), ele[u].begin(), ele[u].end());
  anc[u] = v;
  return {ele[u], u};
}
int main() {
  read(n, m, q);
  for (int i = 1; i <= n; i++) read(p[i]);
  for (int i = 1; i <= m; i++) read(e[i].u), read(e[i].v);
  for (int i = 1; i <= q; i++) {
    read(y[i].o), read(y[i].x);
    if (y[i].o == 2) mrk[y[i].x] = true;
  }
  for (int i = 1; i <= n; i++) {
    anc[i] = i;
    ele[i].push_back(i);
  }
  for (int i = 1; i <= m; i++)
    if (!mrk[i]) {
      merge(e[i].u, e[i].v);
    }
  for (int i = q; i >= 1; i--) {
    if (y[i].o == 2) {
      dat[i] = merge(e[y[i].x].u, e[y[i].x].v);
    }
  }
  for (int i = 1; i <= n; i++) {
    f[find(i)].push(i);
  }
  for (int i = 1; i <= q; i++) {
    if (y[i].o == 1) {
      int ans = pop(find(y[i].x));
      vis[ans] = true;
      print(p[ans], '\n');
    } else {
      int src = find(e[y[i].x].u);
      for (int x : dat[i].first) {
        anc[x] = dat[i].second;
        if (!vis[x]) {
          f[dat[i].second].push(x);
          g[src].push(x);
        }
      }
    }
  }
}
