#include <bits/stdc++.h>

using namespace std;
using ll = long long;

constexpr ll inf = 3e18;

struct Info {
    ll ans = 0, mn = inf;
};

Info operator+(const Info &a, const Info &b) {
    return {max(a.ans, b.ans), min(a.mn, b.mn)};
}

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

void init(int n) {
    sz = 1 << __lg(n) + !!(n & (n - 1));
    tag.assign(sz << 1, -1), t.assign(sz << 1, Info());
}

void apply(int x, ll tg) {
    tag[x] = tg;
    t[x].ans = tg - t[x].mn;
}

void push(int x) {
    if (tag[x] != -1) {
        apply(x << 1, tag[x]);
        apply(x << 1 | 1, tag[x]);
        tag[x] = -1;
    }
}

void pull(int x) {
    t[x] = t[x << 1] + t[x << 1 | 1];
}

Info rangeQuery(int l, int r, int x = 1, int lx = 0, int rx = sz) {
    if (l >= rx || lx >= r) {
        return {};
    }
    if (l <= lx && rx <= r) {
        return t[x];
    }
    int mid = lx + rx >> 1;
    push(x);
    return rangeQuery(l, r, x << 1, lx, mid) + rangeQuery(l, r, x << 1 | 1, mid, rx);
}

void rangeApply(int l, int r, ll tg, int x = 1, int lx = 0, int rx = sz) {
    if (l >= rx || lx >= r) {
        return;
    }
    if (l <= lx && rx <= r) {
        return apply(x, tg);
    }
    int mid = lx + rx >> 1;
    push(x);
    rangeApply(l, r, tg, x << 1, lx, mid), rangeApply(l, r, tg, x << 1 | 1, mid, rx);
    pull(x);
}

namespace SegmentTree {
    vector<int> t;
    int sz = 1;

    void init(int n, vector<int> nxt) {
        sz = 1 << __lg(n) + !!(n & (n - 1));
        t.assign(sz << 1, 1e9);
        for (int i = 0; i < n; ++i) {
            t[i + sz] = nxt[i];
        }
        for (int i = sz - 1; i > 0; --i) {
            t[i] = min(t[i << 1], t[i << 1 | 1]);
        }
    }

    void modify(int x, int v) {
        t[x += sz] = v;
        while (x >>= 1) {
            t[x] = min(t[x << 1], t[x << 1 | 1]);
        }
    }

    int rangeMin(int l, int r) {
        int ans = 1e9;
        for (l += sz, r += sz; l < r; l >>= 1, r >>= 1) {
            if (l & 1) ans = min(ans, t[l++]);
            if (r & 1) ans = min(ans, t[--r]);
        }
        return ans;
    }

    int descend(int mn) { //find first such as nxt[i] < mn
        if (t[1] >= mn) {
            return -1;
        }

        int x = 1;

        while (x < sz) {
            if (t[x << 1 | 1] < mn) {
                x = x << 1 | 1;
            } else {
                x = x << 1;
            }
        }

        return x - sz;
    }
};

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

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

    vector<ll> pref(n + 1);

    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;
    }

    SegmentTree::init(n, nxt);

    init(n);

    for (int i = 0; i < n; ++i) {
        int r = SegmentTree::rangeMin(i, n);
        rangeApply(i, i + 1, pref[r]);
    }

    auto modify = [&](int x, int to) {
        SegmentTree::modify(x, to);

        int mn = SegmentTree::rangeMin(x, n);
        int j = SegmentTree::descend(mn) + 1;
        assert(j <= x);

        rangeApply(j, x + 1, pref[mn]);
    };

    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) {
            nxt[p] = npx;
            modify(p, npx);
        }

        if (np != -1) {
            nxt[np] = x;
            modify(np, x);
        }

        nxt[x] = nx;
        modify(x, nx);

        c[x] = col;
    };

    auto query = [&](int l, int r) { // [l, r)
        int i = SegmentTree::descend(r);
        if (i < l) {
            return pref[r] - pref[l];
        }
        ll ans = rangeQuery(l, i + 1).ans;
        ans = max(ans, pref[r] - pref[i + 1]);
        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;
}