#include<bits/stdc++.h>
#define ALL(v) std::begin(v),std::end(v)
using lint=long long;
using ld=long double;
template<class T>using numr=std::numeric_limits<T>;
void cmn(lint&x,lint y){if(x>y)x=y;}
void cmx(lint&x,lint y){if(x<y)x=y;}
template<class Value,class BinaryOp>struct segtree{ // {{{
    // member variables
    lint n,N;
    BinaryOp op;
    Value id;
    std::vector<Value>table;

    // constructors
    segtree()=default;
    segtree(lint n_, BinaryOp const& op_, Value id_):
        n(n_),
        N(1ll<<(std::numeric_limits<lint>::digits-__builtin_clzll(n)+1)),
        op(op_),
        id(id_),
        table(2*N,id){}

    // other member functions
    void update(lint i){table.at(i)=op(table.at(2*i),table.at(2*i+1));}
    void set(lint i, Value const& x){i+=N;table.at(i)=x;for(i>>=1;i;i>>=1)update(i);}
    void lazy_set(lint i, Value const& x){table.at(i+N)=x;}
    void build(){for(lint i=N-1;i;i--)update(i);}

    Value get(lint i)const{return table.at(i+N);}
    Value query(lint l, lint r)const{
        Value ans=id;
        std::vector<lint>right;
        for(l+=N,r+=N;l<r;l>>=1,r>>=1){
            if(l&1)ans=op(ans,table.at(l++));
            if(r&1)right.push_back(--r);
        }
        std::reverse(ALL(right));
        for(lint x:right)ans=op(ans,table.at(x));
        return ans;
    }
    std::vector<Value>to_vec()const{
        std::vector<Value>ans(n);
        for(lint i=0;i<n;i++)ans.at(i)=table.at(N+i);
        return ans;
    }
}; // }}}
#define ENABLE_DEBUG 0
#ifdef NGTKANA
#include<debug.hpp>
#else
#define DEBUG(...)(void)0
#endif
auto min_fn=[](auto&&x,auto&&y){return std::min(x,y);};
int main(){
    std::cin.tie(nullptr);std::ios_base::sync_with_stdio(false);
    std::cout.setf(std::ios_base::fixed);std::cout.precision(15);
    lint n,k,q;std::cin>>n>>k>>q;
    std::vector<lint>c(n),a(k);
    for(lint&x:c)std::cin>>x;
    for(lint&x:a){std::cin>>x;x--;}
    std::vector<std::vector<lint>>g(n);
    for(lint i=0;i<n-1;i++){
        lint u,v;std::cin>>u>>v;u--,v--;
        g.at(v).push_back(u);
    }
    lint N=4*n-2;
    auto eular=segtree(N,min_fn,std::pair(n,0));
    std::vector<std::pair<lint,lint>>pos(n);
    lint eular_sz=0;
    auto dfs=[&](auto&&f,lint x,lint d)->void{
        pos.at(x).first=eular_sz;
        eular.set(eular_sz++,std::pair(d,x));
        for(lint y:g.at(x)){
            eular.set(eular_sz++,std::pair(d,x));
            cmx(c.at(y),c.at(x));
            f(f,y,d+1);
            eular.set(eular_sz++,std::pair(d,x));
        }
        pos.at(x).second=eular_sz;
        eular.set(eular_sz++,std::pair(d,x));
    };
    dfs(dfs,0,0);
    DEBUG(eular.to_vec(),pos);
    std::vector<std::tuple<lint,lint,lint>>queries(q);
    for(lint i=0;i<q;i++){
        lint com;std::cin>>com;
        if(com==1){
            lint x,y;std::cin>>x>>y;x--,y--;
            queries.at(i)={1,x,y};
        }
        if(com==2){
            lint l,r;std::cin>>l>>r;l--;
            queries.at(i)={2,l,r};
        }
    }
    lint sq=std::sqrt(q);
    std::vector<std::vector<lint>>move(q/sq+1,std::vector<lint>(k));
    for(lint i=0;i<q;i++){
        if(std::get<0>(queries.at(i))==1){
            lint x,y;std::tie(std::ignore,x,y)=queries.at(i);
            move.at(i/sq).at(x)=true;
        }
    }
    DEBUG(sq,queries,move);
    for(lint i=0;i<=q/sq;i++){
        auto seg=segtree(
                k,
                [](auto&&p0,auto&&p1){return std::pair(std::min(p0.first,p1.first),std::max(p0.second,p1.second));},
                std::pair(N,0));
        for(lint j=0;j<k;j++){
            if(move.at(i).at(j))continue;
            seg.set(j,pos.at(a.at(j)));
        }
        std::vector<lint>moving;
        for(lint j=0;j<k;j++){
            if(move.at(i).at(j))moving.push_back(j);
        }
        DEBUG(i,a,seg.to_vec(),eular.to_vec(),moving);
        for(lint j=i*sq;j<std::min((i+1)*sq,q);j++){
            auto&&query=queries.at(j);
            DEBUG(query);
            if(std::get<0>(query)==1){
                lint x,y;std::tie(std::ignore,x,y)=query;
                a.at(x)=y;
            }
            if(std::get<0>(query)==2){
                lint l,r;std::tie(std::ignore,l,r)=query;
                lint L,R;std::tie(L,R)=seg.query(l,r);
                for(lint k_:moving){
                    if(k_<l||r<=k_)continue;
                    cmn(L,pos.at(a.at(k_)).first);
                    cmx(R,pos.at(a.at(k_)).second);
                }
                DEBUG(L,R);
                std::cout<<c.at(eular.query(L,R).second)<<'\n';
            }
        }
    }
}
/*
 * 各頂点から根までのパスの最大値を DFS で前計算です。
 * あとは LCA をオイラーツアーで求めます。
 * クエリ平方分割です。
 * クエリ区間で変わらないようなもの全てについて、
 * オイラーツアー順を min / max セグ木に入れます。
 * すると、取得クエリはクエリ区間でのセグ木の結果に、追加のものも union すればよいです。
 */