#include<iostream>
#include<cstring>
#include<algorithm>
#include<set>

using namespace std;

typedef long long ll;

const int N=2e5+10;

int n,m,q;
ll s[N],g[N<<2];
int lst[N],nxt[N],pos[N],col[N];
set<int> c[N];
struct seg
{
	int l,r,mx;
	ll s;
}tr[N<<2],ans;

ll f(int u,int k)
{
	if(tr[u].l==tr[u].r) return s[tr[u].l]-s[max(k,lst[tr[u].l])];
	if(k>=tr[u<<1].mx)
	{
		int mid=tr[u].l+tr[u].r>>1;
		return max(f(u<<1|1,k),s[mid]-s[k]);
	}
	else return max(f(u<<1,k),g[u<<1|1]? g[u<<1|1]:g[u<<1|1]=f(u<<1|1,tr[u<<1].mx));
}

seg merge(seg u,seg v,int idv)
{
	return {u.l,v.r,max(u.mx,v.mx),max(u.s,f(idv,u.mx))};
}

void build(int u,int l,int r)
{
	tr[u]={l,r,lst[l],s[l]-s[lst[l]]};
	if(l==r) return;
	int mid=l+r>>1;
	build(u<<1,l,mid),build(u<<1|1,mid+1,r);
	tr[u]=merge(tr[u<<1],tr[u<<1|1],u<<1|1);
}

void query(int u,int l,int r)
{
	if(l<=tr[u].l&&tr[u].r<=r)
	{
		ans=merge(ans,tr[u],u);
		return;
	}
	int mid=tr[u].l+tr[u].r>>1;
	if(r<=mid) query(u<<1,l,r);
	else if(l>mid) query(u<<1|1,l,r);
	else query(u<<1,l,r),query(u<<1|1,l,r);
}

void modify(int u,int x,int k)
{
	return;
	if(tr[u].l==tr[u].r)
	{
		lst[x]=tr[u].mx=k;
		return;
	}
	int mid=tr[u].l+tr[u].r>>1;
	if(x<=mid) modify(u<<1,x,k);
	else modify(u<<1|1,x,k);
	g[u<<1|1]=0;
	tr[u]=merge(tr[u<<1],tr[u<<1|1],u<<1|1);
}

int getl(int u,int k)
{
	if(tr[u].l==tr[u].r) return tr[u].l;
	if(tr[u<<1].mx>=k) return getl(u<<1,k);
	else return getl(u<<1|1,k);
}

int main()
{
	scanf("%d%d%d",&n,&m,&q);
	for(int i=1;i<=m;i++) c[i].insert(0),c[i].insert(n+1);
	for(int i=1;i<=n;i++) scanf("%lld",&s[i]),s[i]+=s[i-1];
	for(int i=1;i<=n;i++)
	{
		int k;
		scanf("%d",&k);
		col[i]=k;
		nxt[lst[i]=pos[k]]=i;
		pos[k]=i;
		c[k].insert(i);
	}
	build(1,1,n);
	while(q--)
	{
		int op,l,r;
		scanf("%d%d%d",&op,&l,&r);
		if(op==1)
		{
			int l0=getl(1,l-1);
			ans={0,0,0,0};
			query(1,l0,r);
			printf("%lld\n",max(ans.s,s[l0-1]-s[l-1]));
		}
		else
		{
			if(col[l]==r) continue;
			if(nxt[l]) modify(1,nxt[l],lst[l]);
			nxt[lst[l]]=nxt[l];
			c[col[l]].erase(l);
			c[col[l]=r].insert(l);
			auto it1=c[r].lower_bound(l);
			auto it2=it1++;
			it1--;
			nxt[l]=*it2==n+1? 0:*it2;
			modify(1,l,*it1);
			nxt[*it1]=l;
			if(nxt[l]) modify(1,nxt[l],l);
		}
	}
	
	return 0;
}