const int MAXN=1e5+5,MAXC=1e6+5;
int blk_sz;
struct Edge{
	int to,next;
}edge[MAXN<<1];
int head[MAXN],edge_cnt,dfn1[MAXN],dfn2[MAXN],invn[MAXN<<1],dfs_t;
void AddEdge(int u,int v){
	edge[++edge_cnt]=Edge{v,head[u]};
	head[u]=edge_cnt;
}
void dfs(int u,int fa){
	dfn1[u]=++dfs_t;
	invn[dfs_t]=u;
	for(int i=head[u];i;i=edge[i].next){
		int v=edge[i].to;
		if(v==fa)continue;
		dfs(v,u);
	}
	dfn2[u]=++dfs_t;
	invn[dfs_t]=u;
}
namespace LCA{
	int d[MAXN],sz[MAXN],f[MAXN];
	int h_son[MAXN],mson[MAXN],p[MAXN];
	void dfs_1(int u,int fa,int depth){
		sz[u]=1;f[u]=fa;d[u]=depth;mson[u]=0;
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].to;
			if(v==fa)
			continue;
			dfs_1(v,u,depth+1);
			sz[u]+=sz[v];
			if(sz[v]>mson[u])
			h_son[u]=v,mson[u]=sz[v];
		}
	}
	void dfs_2(int u,int top){
		p[u]=top;
		if(mson[u])dfs_2(h_son[u],top);
		for(int i=head[u];i;i=edge[i].next){
			int v=edge[i].to;
			if(v==f[u]||v==h_son[u])
			continue;
			dfs_2(v,v);
		}
	}
	void init(int root){dfs_1(root,0,0);dfs_2(root,root);}
	int query(int u,int v){
		while(p[u]!=p[v]){
			if(d[p[u]]<d[p[v]])swap(u,v);
			u=f[p[u]];
		}
		return d[u]<d[v]?u:v;
	}
};
struct query{
	int l,r,t,idx;
	bool operator < (const query &b)const{
		if(l/blk_sz!=b.l/blk_sz)return l<b.l;
		if(r/blk_sz!=b.r/blk_sz)return ((l/blk_sz)&1)?(r<b.r):(r>b.r);
		return ((r/blk_sz)&1)?(t<b.t):(t>b.t); 
	}
}q[MAXN];
struct opt{
	int pos,pre,now;
}p[MAXN];
int cc[MAXN],lc[MAXN],val[MAXN],w[MAXN];
int col[MAXN],qn,pn,lef=1,rig=0;
LL ans[MAXN],cur_ans;
bool vis[MAXN];
void update_ans(int idx,int c){
	if(!vis[idx])
	cur_ans+=1LL*val[c]*w[++col[c]];
	else
	cur_ans-=1LL*val[c]*w[col[c]--];
	vis[idx]=!vis[idx];
}
void update_val(opt &p){
	if(vis[p.pos]){
		update_ans(p.pos,cc[p.pos]);
		cc[p.pos]=p.now;
		update_ans(p.pos,cc[p.pos]);
	}
	else
	cc[p.pos]=p.now;
	swap(p.pre,p.now);
}
int main()
{
	int n=read_int(),m=read_int(),q0=read_int();
	blk_sz=pow(n,2.0/3);
	_rep(i,1,m)val[i]=read_int();
	_rep(i,1,n)w[i]=read_int();
	_for(i,1,n){
		int u=read_int(),v=read_int();
		AddEdge(u,v);
		AddEdge(v,u);
	}
	_rep(i,1,n)cc[i]=lc[i]=read_int();
	LCA::init(1);
	dfs(1,0);
	while(q0--){
		int type=read_int();
		if(type==0){
			pn++;
			int pos=read_int(),v=read_int();
			p[pn].pos=pos,p[pn].pre=lc[pos],p[pn].now=(lc[pos]=v);
		}
		else{
			qn++;
			int u=read_int(),v=read_int();
			if(dfn1[u]>dfn1[v])swap(u,v);
			if(LCA::query(u,v)==u)
			q[qn].l=dfn1[u],q[qn].r=dfn1[v];
			else
			q[qn].l=dfn2[u],q[qn].r=dfn1[v];
			q[qn].t=pn,q[qn].idx=qn;
		}
	}
	sort(q+1,q+qn+1);
	int tim=0;
	_rep(i,1,qn){
		while(lef>q[i].l)lef--,update_ans(invn[lef],cc[invn[lef]]);
		while(rig<q[i].r)rig++,update_ans(invn[rig],cc[invn[rig]]);
		while(lef<q[i].l)update_ans(invn[lef],cc[invn[lef]]),lef++;
		while(rig>q[i].r)update_ans(invn[rig],cc[invn[rig]]),rig--;
		while(tim<q[i].t)update_val(p[++tim]);
		while(tim>q[i].t)update_val(p[tim--]);
		int u=invn[q[i].l],v=invn[q[i].r],p=LCA::query(u,v);
		if(u==p)
		ans[q[i].idx]=cur_ans;
		else{
			update_ans(p,cc[p]);
			ans[q[i].idx]=cur_ans;
			update_ans(p,cc[p]);
		}
	}
	_rep(i,1,qn)
	enter(ans[i]);
	return 0;
}

const int MAXN=1e5+5;
int blk_sz,a[MAXN],b[MAXN],col[MAXN],temp[MAXN];
struct query{
	int l,r,idx;
	bool operator < (const query &b)const{
		if(l/blk_sz!=b.l/blk_sz)return l<b.l;
		return r<b.r; 
	}
}q[MAXN];
LL ans[MAXN],cur,tans;
void add(int v,LL &ans){
	col[v]++;
	ans=max(ans,1LL*col[v]*b[v]);
}
void del(int v){col[v]--;}
int main()
{
	int n=read_int(),qn=read_int();
	blk_sz=n/sqrt(qn)+1;
	_rep(i,1,n)a[i]=b[i]=read_int();
	sort(b+1,b+n+1);
	int m=unique(b+1,b+n+1)-b;
	_rep(i,1,n)a[i]=lower_bound(b+1,b+m,a[i])-b;
	_for(i,0,qn)q[i].l=read_int(),q[i].r=read_int(),q[i].idx=i;
	sort(q,q+qn);
	int lef=1,rig=0,lst=-1;
	_for(i,0,qn){
		if(q[i].l/blk_sz==q[i].r/blk_sz){
			tans=0;
			_rep(j,q[i].l,q[i].r){
				temp[a[j]]++;
				tans=max(tans,1LL*temp[a[j]]*b[a[j]]);
			}
			_rep(j,q[i].l,q[i].r)temp[a[j]]--;
			ans[q[i].idx]=tans;
		}
		else{
			if(q[i].l/blk_sz!=lst){
				while(lef<=rig)del(a[lef++]);
				lst=q[i].l/blk_sz;
				rig=min(lst*blk_sz+blk_sz-1,n);
				lef=rig+1,cur=0;
			}
			while(rig<q[i].r)add(a[++rig],cur);
			int tlef=lef;tans=cur;
			while(tlef>q[i].l)add(a[--tlef],tans);
			while(tlef<lef)del(a[tlef++]);
			ans[q[i].idx]=tans;
		}
	}
	_for(i,0,qn)enter(ans[i]);
	return 0;
}