#include <bits/stdc++.h>
#define FOR(i,j,k) for(int i=j; i<=k; ++i)
#define ROF(i,j,k) for(int i=j; i>=k; --i)
inline int read (void) {
  int x = 0, f = 1, ch = getchar();
  while(!isdigit(ch)) { if(ch == '-') f = -f; ch = getchar(); }
  while(isdigit(ch)) { x = x * 10 + ch - '0'; ch = getchar(); }
  return x * f;
}
using ll = long long;
const int maxn = 200005;
const int maxm = 524288;
namespace sgt {
  #define mid (l + r >> 1)
  ll t[maxm];
  void modify (int l, int r, int q, ll c, int k=1) {
    if(l == r) { t[k] = c; return ; }
    if(q <= mid) modify (l, mid, q, c, k<<1);
    else modify (mid+1, r, q, c, k<<1|1);
    t[k] = std::max(t[k<<1], t[k<<1|1]);
  }
  ll query (int l, int r, int ql, int qr, int k=1) {
    if(ql <= l && r <= qr) return t[k];
    if(ql <= mid)
      if(mid < qr) return std::max(query (l, mid, ql, qr, k<<1), query (mid+1, r, ql, qr, k<<1|1));
      else return query (l, mid, ql, qr, k<<1);
    else return query (mid+1, r, ql, qr, k<<1|1);
  }
  #undef mid
}
int c[maxn], nxt[maxn], lp[maxn];
ll a[maxn];
std::set <int> s[maxn];
struct Node {
  std::priority_queue <int, std::vector <int>, std::greater <int> > q, q1;
  inline void push (int x) { q.push(x); }
  inline void pop (int x) { q1.push(x); }
  inline int top (void) {
    while(!q1.empty() && q1.top() == q.top())
      q.pop(), q1.pop();
    return q.top();
  }
  inline void clear (void) {
    while(!q.empty()) q.pop();
    while(!q1.empty()) q1.pop();
  }
} node;
int main (void) {
  int n = read(), m = read(), q = read();
  if(n <= 5000) {
    FOR(i,1,n) a[i] = a[i-1] + read();
    FOR(i,1,n) c[i] = read();
    FOR(i,1,m) s[i].insert (n+1);
    ROF(i,n,1) {
      nxt[i] = *s[c[i]].begin();
      s[c[i]].insert (i);
    }
    FOR(i,1,m) s[i].insert (0);
    while(q--) {
      int opt = read(), l = read(), r = read();
      if(opt == 1) {
        ll ans = 0;
        for(int L=l, R=l; R<=r; ++R) {
          node.push(nxt[R]);
          while(node.top() == R)
            node.pop(nxt[L ++]);
          ans = std::max(a[R] - a[L-1], ans);
        } node.clear ();
        printf("%lld\n", ans);
      } else {
        nxt[*prev(s[c[l]].lower_bound (l))] = *s[c[l]].upper_bound (l);
        s[c[l]].erase (l);
        s[c[l] = r].insert (l);
        nxt[*prev(s[c[l]].lower_bound (l))] = l;
        nxt[l] = *s[c[l]].upper_bound (l);
      }
    }
  } else if(m <= 10) {
    FOR(i,1,n) a[i] = a[i-1] + read();
    FOR(i,1,n) c[i] = read();
    FOR(i,1,m) s[i].insert (n+1);
    ROF(i,n,1) {
      nxt[i] = *s[c[i]].begin();
      s[c[i]].insert (i);
    }
    FOR(i,1,m) s[i].insert (0);
    for(int L=1, R=1; R<=n; ++R) {
      node.push(nxt[R]);
      while(node.top() == R)
        node.pop(nxt[L ++]);
      lp[R] = L;
      sgt::modify (1, n, R, a[R] - a[L-1]);
    } node.clear ();
    while(q--) {
      int opt = read(), l = read(), r = read();
      if(opt == 1) {
        if(lp[r] <= l) printf("%lld\n", a[r] - a[l-1]);
        else {
          int L = std::upper_bound (lp+1, lp+n+1, l) - lp;
          printf("%lld\n", std::max(a[L-1] - a[l-1], sgt::query (1, n, L, r)));
        }
      } else {
        nxt[*prev(s[c[l]].lower_bound (l))] = *s[c[l]].upper_bound (l);
        s[c[l]].erase (l);
        s[c[l] = r].insert (l);
        nxt[*prev(s[c[l]].lower_bound (l))] = l;
        nxt[l] = *s[c[l]].upper_bound (l);
        for(int L=std::max(1, l-20), R=std::max(1, l-20); R<=l; ++R) {
          node.push(nxt[R]);
          while(node.top() == R)
            node.pop(nxt[L ++]);
          if(R >= l - 10) lp[R] = L;
          sgt::modify (1, n, R, a[R] - a[L-1]);
        } node.clear ();
      }
    }
  } else {
    FOR(i,1,n) a[i] = a[i-1] + read();
    FOR(i,1,n) c[i] = read();
    FOR(i,1,m) s[i].insert (n+1);
    ROF(i,n,1) {
      nxt[i] = *s[c[i]].begin();
      s[c[i]].insert (i);
    }
    FOR(i,1,m) s[i].insert (0);
    for(int L=1, R=1; R<=n; ++R) {
      node.push(nxt[R]);
      while(node.top() == R)
        node.pop(nxt[L ++]);
      lp[R] = L;
      sgt::modify (1, n, R, a[R] - a[L-1]);
    } node.clear ();
    while(q--) {
      int opt = read(), l = read(), r = read();
      if(lp[r] <= l) printf("%lld\n", a[r] - a[l-1]);
      else {
        int L = std::upper_bound (lp+1, lp+n+1, l) - lp;
        printf("%lld\n", std::max(a[L-1] - a[l-1], sgt::query (1, n, L, r)));
      }
    }
  }
  return 0;
}