#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
typedef vector<int> vint;

int read() {
	int a = 0, b = 0; char c = getchar();
	while (c < '0' || c > '9') b ^= (c == '-'), c = getchar();
	while (c >= '0' && c <= '9') a = a * 10 - 48 + c, c = getchar();
	return b ? -a : a;
}

const int N = 200005;

ll a[N], sa[N];
mt19937 rnd(20221210);
typedef unsigned int uint;
int c[N], n, m, q;

struct pir {
	int a, b;
};
struct node {
	int ls, rs, val, siz, sec;
	pir sq;
	uint pri;
};

const int NS = 1000005;
struct treap {
	node tr[NS];
	int cnt, rot;
	function <pir(pir, pir)> ud;
	void init(function <pir(pir, pir)> f, pir q) { cnt = rot = 0, ud = f; tr[0].sec = q.b, tr[0].val = q.a, tr[0].sq = q; }
	int nnode(int val, int sec) { return tr[++cnt] = node{0, 0, val, 1, sec, pir{val, sec}, uint(rnd())}, cnt; }
	
	void upd(int rt) {
		if (!rt) return;
		node &p = tr[rt];
		p.siz = tr[p.ls].siz + 1 + tr[p.rs].siz;
		p.sq = ud(ud(tr[p.ls].sq, pir{p.val, p.sec}), tr[p.rs].sq);
	}
	
	pir split(int rt, int k) { // v <= k and k < v
		if (!rt) return pir{0, 0};
		node &p = tr[rt];
		if (p.val <= k) {
			pir o = split(p.rs, k);
			p.rs = o.a, o.a = rt, upd(rt);
			return o;
		} else {
			pir o = split(p.ls, k);
			p.ls = o.b, o.b = rt, upd(rt);
			return o;
		}
	}
	
	int merge(int a, int b) {
		if (!a || !b) return a + b;
		node &pa = tr[a], &pb = tr[b];
		if (pa.pri < pb.pri) {
			pa.rs = merge(pa.rs, b);
			upd(a); return a;
		} else {
			pb.ls = merge(a, pb.ls);
			upd(b); return b;
		}
	}
	
	void ins(int vl, int se) {
		int id = nnode(vl, se);
		pir o = split(rot, vl);
		o.a = merge(o.a, id);
		rot = merge(o.a, o.b);
	}
	void era(int vl) {
		pir o = split(rot, vl - 1);
		pir p = split(o.b, vl);
		rot = merge(o.a, p.b);
	}
	pir leq(int k, int rt = -1) {
		if (rt == -1) rt = rot;
		node &p = tr[rt];
		if (!rt) return p.sq;
		if (p.val <= k) return ud(ud(tr[p.ls].sq, pir{p.val, p.sec}), leq(k, p.rs));
		else return leq(k, p.ls);
	}
	pir req(int k, int rt = -1) {
		if (rt == -1) rt = rot;
		node &p = tr[rt];
		if (!rt) return p.sq;
		if (p.val < k) return req(k, p.rs);
		else return ud(ud(pir{p.val, p.sec}, tr[p.rs].sq), req(k, p.ls));
	}
	
} T1, T2;
struct treap2 {
	struct node2 {
		int ls, rs, val, siz, sec;
		ll vl;
		uint pri;
	};
	node2 tr[NS];
	int cnt, rot;
	int nnode(int val, int sec) { return tr[++cnt] = node2{0, 0, val, 1, sec, sa[sec] - sa[val - 1], uint(rnd())}, cnt; }
	
	void upd(int rt) {
		if (!rt) return;
		node2 &p = tr[rt];
		p.siz = tr[p.ls].siz + 1 + tr[p.rs].siz;
		p.vl = max(tr[p.ls].vl, max(sa[p.sec] - sa[p.val - 1], tr[p.rs].vl));
	}
	
	pir split(int rt, int k) { // v <= k and k < v
		if (!rt) return pir{0, 0};
		node2 &p = tr[rt];
		if (p.val <= k) {
			pir o = split(p.rs, k);
			p.rs = o.a, o.a = rt, upd(rt);
			return o;
		} else {
			pir o = split(p.ls, k);
			p.ls = o.b, o.b = rt, upd(rt);
			return o;
		}
	}
	
	int merge(int a, int b) {
		if (!a || !b) return a + b;
		node2 &pa = tr[a], &pb = tr[b];
		if (pa.pri < pb.pri) {
			pa.rs = merge(pa.rs, b);
			upd(a); return a;
		} else {
			pb.ls = merge(a, pb.ls);
			upd(b); return b;
		}
	}
	
	void ins(int vl, int se) {
		if (vl > se || vl <= 0 || se > n) return;
		int id = nnode(vl, se);
		pir o = split(rot, vl);
		o.a = merge(o.a, id);
		rot = merge(o.a, o.b);
	}
	void era(int vl) {
		pir o = split(rot, vl - 1);
		pir p = split(o.b, vl);
		rot = merge(o.a, p.b);
	}
	ll qry(int l, int r, int rt = -1, int gl = 0, int gr = 0) {
		if (rt == -1) rt = rot;
		node2 &p = tr[rt];
		if (!rt) return -1;
		if (gl && gr) return p.vl;
		if (p.val < l) return qry(l, r, p.rs, gl, gr);
		if (r < p.sec) return qry(l, r, p.ls, gl, gr);
		return max(sa[p.sec] - sa[p.val - 1], max(qry(l, r, p.ls, gl, 1), qry(l, r, p.rs, 1, gr)));
	}
	
} T3;

set <int> s[N];


void ins(int l, int r) {
	pir A = T2.leq(r), B = T1.req(l);
	swap(A.a, A.b);
	if (l <= A.a || B.b <= r) return;
	T3.era(A.a + 1);
	T3.ins(A.a + 1, r - 1);
	T3.ins(l + 1, B.b - 1);
	T2.ins(r, l);
	T1.ins(l, r);
}


void era(int l, int r) {
	T1.era(l), T2.era(r);
	pir A = T2.leq(r), B = T1.req(l);
	swap(A.a, A.b);
	if (l <= A.a || B.b <= r) return;
	T3.era(A.a + 1);
	T3.era(l + 1);
	T3.ins(A.a + 1, B.b - 1);
}

const int INF = 0x3f3f3f3f;

int main() {
//	freopen("a.in", "r", stdin);
//	freopen("a.out", "w", stdout);
	n = read(), m = read(), q = read();
	for (int i = 1; i <= n; ++i) a[i] = read(), sa[i] = sa[i - 1] + a[i];
	for (int i = 1; i <= n; ++i) c[i] = read(), s[c[i]].insert(i);
	T1.init([&](pir a, pir b) { return a.b < b.b ? a : b; }, pir{INF, INF}); // T1 : key = l, qry : min(r)
	T2.init([&](pir a, pir b) { return a.b < b.b ? b : a; }, pir{0, 0}); // T2 : key = r, qry : max(l)
	
	for (int i = 1; i <= n; ++i) {
		auto p = s[c[i]].upper_bound(i);
		if (p != s[c[i]].end()) ins(i, *p);
	}
	
	while (q--) {
		int op = read(), l = read(), r = read();
		if (op == 1) {
			int xl = T2.leq(r).b, mr = T1.req(l).b; 
			ll ans = max(sa[r] - sa[max(l - 1, xl)], sa[min(r, mr - 1)] - sa[l - 1]);
			ans = max(ans, T3.qry(l, r));
			cout << ans << '\n';
		} else {
			auto p = s[c[l]].upper_bound(l);
			if (p != s[c[l]].end()) era(l, *p);
			--p;
			if (p != s[c[l]].begin()) --p, era(*p, l);
			s[c[l]].erase(l);
			c[l] = r;
			p = s[c[l]].upper_bound(l);
			if (p != s[c[l]].begin() && p != s[c[l]].end()) {
				auto q = prev(p);
				era(*q, *p);
				ins(*q, l);
			}
			if (p != s[c[l]].end()) ins(l, *p);
			s[c[l]].insert(l);
		}
	}
	
	return 0;
}