/* -*- coding: utf-8 -*-
 *
 * 1030.cc:  No.1030 だんしんぐぱーりない - yukicoder
 */

#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
 
using namespace std;

/* constant */

const int MAX_N = 100000;
const int MAX_K = 100000;
const int MAX_E2 = 1 << 18; // = 262144
const int BN = 17;

/* typedef */

typedef vector<int> vi;
typedef queue<int> qi;

template <typename T, const int MAX_E2, const int BN>
struct SegTreeLCA {
  int n, e2;
  T nodes[MAX_E2];
  int ps[MAX_E2 / 2][BN], ds[MAX_E2 / 2];
  SegTreeLCA() {}

  void init(int _n) {
    n = _n;
    for (e2 = 1; e2 < n; e2 <<= 1);
    memset(nodes, -1, sizeof(nodes));
    memset(ps, -1, sizeof(ps));
    memset(ds, 0, sizeof(ds));
  }

  T &get(int i) { return nodes[e2 - 1 + i]; }

  int __lca(int u, int v) {
    if (u < 0) return v;
    if (v < 0) return u;
    if (ds[u] > ds[v]) swap(u, v);

    for (int i = BN - 1; i >= 0; i--)
      if (((ds[v] - ds[u]) >> i) & 1) v = ps[v][i];
    if (u == v) return u;

    for(int i = BN - 1; i >= 0; i--)
      if (ps[u][i] != ps[v][i])
	u = ps[u][i], v = ps[v][i];

    return ps[u][0];
  }
  
  void setall() {
    for (int j = e2 - 2; j >= 0; j--)
      nodes[j] = __lca(nodes[j * 2 + 1], nodes[j * 2 + 2]);
  }
  
  void set(int i, T v) {
    int j = e2 - 1 + i;
    nodes[j] = v;
    while (j > 0) {
      j = (j - 1) / 2;
      nodes[j] = __lca(nodes[j * 2 + 1], nodes[j * 2 + 2]);
    }
  }

  T lca_range(int r0, int r1, int k, int i0, int i1) {
    if (r1 <= i0 || i1 <= r0) return -1;
    if (r0 <= i0 && i1 <= r1) return nodes[k];

    int im = (i0 + i1) / 2;
    T v0 = lca_range(r0, r1, k * 2 + 1, i0, im);
    T v1 = lca_range(r0, r1, k * 2 + 2, im, i1);
    return __lca(v0, v1);
  }
  T lca_range(int r0, int r1) { return lca_range(r0, r1, 0, 0, e2); }
};

/* global variables */

int cs[MAX_N], as[MAX_K];
vi nbrs[MAX_N];
SegTreeLCA<int,MAX_E2,BN> st;

/* subroutines */

/* main */

int main() {
  int n, k, qn;
  scanf("%d%d%d", &n, &k, &qn);

  st.init(k);
  
  for (int i = 0; i < n; i++) scanf("%d", cs + i);
  for (int i = 0; i < k; i++) scanf("%d", as + i), as[i]--;

  for (int i = 1; i < n; i++) {
    int a, b;
    scanf("%d%d", &a, &b);
    a--, b--;
    st.ps[a][0] = b;
    nbrs[b].push_back(a);
  }

  for (int i = 0; i + 1 < BN; i++)
    for (int u = 0; u < n; u++)
      st.ps[u][i + 1] = (st.ps[u][i] >= 0) ? st.ps[st.ps[u][i]][i] : -1;
	    
  st.ds[0] = 0;
  qi q;
  q.push(0);

  while (! q.empty()) {
    int u = q.front(); q.pop();
    int up = st.ps[u][0];
    if (up >= 0 && cs[u] < cs[up]) cs[u] = cs[up];

    int vd = st.ds[u] + 1;
    vi &nbru = nbrs[u];
    for (vi::iterator vit = nbru.begin(); vit != nbru.end(); vit++) {
      int v = *vit;
      st.ds[v] = vd;
      q.push(v);
    }
  }
  //for (int i = 0; i < n; i++) printf("%d: %d,%d\n", i, ls[i], rs[i]);

  for (int i = 0; i < k; i++) st.get(i) = as[i];
  st.setall();

  while (qn--) {
    int t;
    scanf("%d", &t);

    if (t == 1) {
      int x, y;
      scanf("%d%d", &x, &y);
      x--, y--;
      st.set(x, y);
    }
    else {
      int l, r;
      scanf("%d%d", &l, &r);
      l--;
      int v = st.lca_range(l, r);
      printf("%d\n", cs[v]);
    }
  }
  return 0;
}