#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr int N = 2e5 + 228;

ll pref[N];
int n;

namespace ST {
    struct Info {
        ll ans = 0;
        int mn = 0;
    };

    vector<Info> t;
    vector<ll> ansL;
    int sz = 1;

    ll vertexQuery(int x, int mn) {
        if (x >= sz) {
            if (x - sz >= n) {
                return 0;
            }
            return t[x].mn >= mn ? 0 : pref[mn] - pref[x - sz + 1];
        }

        if (t[x << 1 | 1].mn < mn) {
            return max(ansL[x], vertexQuery(x << 1 | 1, mn));
        } else {
            return vertexQuery(x << 1, mn);
        }
    }

    void pull(int x) {
        t[x].mn = min(t[x << 1].mn, t[x << 1 | 1].mn);
        ansL[x] = vertexQuery(x << 1, t[x << 1 | 1].mn);
        t[x].ans = max(ansL[x], t[x << 1 | 1].ans);
    }

    void init(int n, vector<int> nxt) {
        sz = 1 << __lg(n) + !!(n & (n - 1));
        t.assign(sz << 1, Info());
        ansL.assign(sz << 1, 0);

        for (int i = 0; i < n; ++i) {
            t[i + sz].mn = nxt[i];
            t[i + sz].ans = 0;
        }
        for (int i = sz - 1; i > 0; --i) {
            pull(i);
        }
    }

    vector<int> stk;

    void rangeQuery(int l, int r, int x, int lx = 0, int rx = sz) {
        if (l >= rx || lx >= r) {
            return;
        }
        if (l <= lx && rx <= r) {
            return stk.push_back(x);
        }
        int mid = lx + rx >> 1;
        rangeQuery(l, r, x << 1, lx, mid), rangeQuery(l, r, x << 1 | 1, mid, rx);
    }

    void modify(int x, int i) {
        t[x + sz].mn = i;
        t[x + sz].ans = 0;
        for (x += sz; x >>= 1;) {
            pull(x);
        }
    }

    vector<int> rangeQuery(int l, int r) {
        stk.clear();
        rangeQuery(l, r, 1, 0, sz);
        return stk;
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int m, q;
    cin >> n >> m >> q;

    for (int i = 1; i <= n; ++i) {
        cin >> pref[i];
        pref[i] += pref[i - 1];
    }

    vector<int> c(n), nxt(n, n), last(m, -1);
    vector<set<int>> st(m);

    for (int i = 0; i < m; ++i) {
        st[i].insert(-1);
        st[i].insert(n);
    }

    for (int i = 0; i < n; ++i) {
        cin >> c[i];
        c[i] -= 1;
        st[c[i]].insert(i);

        if (last[c[i]] != -1) {
            nxt[last[c[i]]] = i;
        }
        last[c[i]] = i;
    }

    ST::init(n, nxt);

    auto modify = [&](int x, int to) {
        nxt[x] = to;
        ST::modify(x, to);
    };

    auto replace = [&](int x, int col) {
        if (c[x] == col) {
            return;
        }

        st[c[x]].erase(x);
        st[col].insert(x);

        int p = *prev(st[c[x]].lower_bound(x));
        int np = *prev(st[col].lower_bound(x));
        int nx = *st[col].upper_bound(x);
        int npx = *st[c[x]].upper_bound(p);

        if (p != -1) {
            modify(p, npx);
        }
        if (np != -1) {
            modify(np, x);
        }
        modify(x, nx);

        c[x] = col;
    };

    auto query = [&](int l, int r) { // [l, r)
        vector<int> stk = ST::rangeQuery(l, r);
        int mn = r;
        ll ans = ST::vertexQuery(stk.back(), r);

        for (int k = stk.size() - 1; k >= 0; --k) {
            mn = min(mn, ST::t[stk[k]].mn);
            if (k > 0) {
                ans = max(ans, ST::vertexQuery(stk[k - 1], mn));
            }
        }

        if (mn >= l) {
            ans = max(ans, pref[mn] - pref[l]);
        }

        return ans;
    };

    while (q--) {
        int tp, a, b;
        cin >> tp >> a >> b;
        a -= 1, b -= 1;

        if (tp == 1) {
            cout << query(a, b + 1) << '\n';
        } else {
            replace(a, b);
        }
    }

    return 0;
}