#include <bits/stdc++.h>
using namespace std;
const int N = 3e5;
const int inf = 1 << 30;
#define pii pair<int, int>
#define pl first
#define pr second
pii operator+(pii x, pii y)
{
    return {max(x.pl, y.pl), min(x.pr, y.pr)};
}
bool empty(pii x) { return x.pl > x.pr; }
int n, m, q;
int L;
int a[N + 5], b[N + 5];
vector<int> c[N + 5];
int ord[N + 5], rk[N + 5];
vector<int> lc[N + 5], rc[N + 5];
struct Segtr
{
    int tp;
    struct Tr
    {
        pii val;
        int lc, rc;
        Tr(pii val = {0, inf}, int lc = -1, int rc = -1) : val(val), lc(lc), rc(rc) {}
    };
    vector<Tr> tr;
    vector<int> rt;
#define lc(x) tr[x].lc
#define rc(x) tr[x].rc
    void push_up(int x)
    {
        tr[x].val = tr[lc(x)].val + tr[rc(x)].val;
    }
    int build(int l, int r)
    {
        int x = tr.size();
        tr.push_back(Tr());
        if (l == r)
        {
            tr[x] = Tr({0, c[l][tp]});
            return x;
        }
        int mid = l + r >> 1;
        lc(x) = build(l, mid);
        rc(x) = build(mid + 1, r);
        push_up(x);
        return x;
    }
    int modify(int l, int r, int p, int x)
    {
        int y = tr.size();
        tr.push_back(tr[x]);
        if (l == r)
        {
            tr[y] = Tr({c[p][tp], inf});
            return y;
        }
        int mid = l + r >> 1;
        if (p <= mid)
            lc(y) = modify(l, mid, p, lc(x));
        else
            rc(y) = modify(mid + 1, r, p, rc(x));
        push_up(y);
        return y;
    }
    void init(int t)
    {
        tp = t;
        rt.resize(n + 1);
        rt[0] = build(0, n - 1);
        for (int i = 0; i < n; i++)
        {
            int p = ord[i];
            rt[i + 1] = modify(0, n - 1, p, rt[i]);
        }
    }
    int query(int l, int r, pii val, int x)
    {
        if (!empty(val + tr[x].val))
            return -1;
        if (l == r)
            return l;
        int mid = l + r >> 1, ans = -1;
        ans = query(l, mid, val, lc(x));
        if (ans == -1)
            ans = query(mid + 1, r, val + tr[lc(x)].val, rc(x));
        return ans;
    }
    pii get(int l, int r, int qr, int x)
    {
        if (r <= qr)
            return tr[x].val;
        int mid = l + r >> 1;
        pii ans = get(l, mid, qr, lc(x));
        if (qr > mid)
            ans = ans + get(mid + 1, r, qr, rc(x));
        return ans;
    }
    int query(pii val, int p)
    {
        return query(0, n - 1, val, rt[p]);
    }
#undef lc
#undef rc
};
vector<Segtr> T;
set<int> lac, rac;
struct Segtr2
{
    pii tr[N * 4 + 5];
#define lc id << 1
#define rc id << 1 | 1
    void push_up(int id)
    {
        tr[id] = tr[lc] + tr[rc];
    }
    void build(int l, int r, int id)
    {
        if (l == r)
        {
            tr[id] = {min(a[l], b[l % m]), min(a[l], b[l % m])};
            return;
        }
        int mid = l + r >> 1;
        build(l, mid, lc);
        build(mid + 1, r, rc);
        push_up(id);
    }
    void change(int l, int r, int p, int id)
    {
        if (l == r)
        {
            tr[id] = {min(a[p], b[p % m]), max(a[p], b[p % m])};
            return;
        }
        int mid = l + r >> 1;
        if (p <= mid)
            change(l, mid, p, lc);
        else
            change(mid + 1, r, p, rc);
        push_up(id);
    }
    int query(int l, int r, pii val, int id)
    {
        if (!empty(tr[id] + val))
            return -1;
        if (l == r)
            return l;
        int mid = l + r >> 1, ans;
        ans = query(l, mid, val, lc);
        if (ans == -1)
            ans = query(mid + 1, r, val + tr[lc], rc);
        return ans;
    }
    pii get(int l, int r, int qr, int id)
    {
        if (r <= qr)
            return tr[id];
        int mid = l + r >> 1;
        pii ans = get(l, mid, qr, lc);
        if (qr > mid)
            ans = ans + get(mid + 1, r, qr, rc);
        return ans;
    }
#undef lc
#undef rc
} T2;
bool cmp(int x, int y)
{
    return c[x][0] < c[y][0];
}
void del(int p)
{
    // fprintf(stderr, "%d %d\n", p, rk[p]);
    if (a[p] < c[p][0])
        lac.erase(rk[p] + 1);
    else
        rac.erase(rk[p]);
}
void ins(int p)
{
    if (a[p] < c[p][0])
        lac.insert(rk[p] + 1);
    else
        rac.insert(rk[p]);
}
void prep()
{
    reverse(a, a + n);
    reverse(b, b + m);
    L = max(2, (m * 2 + n - 1) / n);
    for (int i = 0; i < L * n; i++)
        c[i % n].push_back(b[i % m]);
    for (int i = 0; i < n; i++)
        ord[i] = i;
    sort(ord, ord + n, cmp);
    for (int i = 0; i < n; i++)
        rk[ord[i]] = i;
    lc[0].resize(L);
    for (int i = 1; i <= n; i++)
    {
        int p = ord[i - 1];
        lc[i] = c[p];
        for (int j = 0; j < L; j++)
        {
            lc[i][j] = max(lc[i][j], lc[i - 1][j]);
            if (j > 0)
                lc[i][j] = max(lc[i][j], lc[i][j - 1]);
        }
    }
    rc[n].resize(L, inf);
    for (int i = n - 1; i >= 0; i--)
    {
        int p = ord[i];
        rc[i] = c[p];
        for (int j = 0; j < L; j++)
        {
            rc[i][j] = min(rc[i][j], rc[i + 1][j]);
            if (j > 0)
                rc[i][j] = min(rc[i][j], rc[i][j - 1]);
        }
    }
    lac.insert(0);
    rac.insert(n);
    T.resize(L);
    for (int i = 0; i < L; i++)
        T[i].init(i);
    T2.build(0, n - 1, 1);
    for (int i = 0; i < n; i++)
        ins(i);
}
int getans(int qv, pii val)
{
    return qv <= val.pl ? val.pl : qv >= val.pr ? val.pr
                                                : qv;
}
int update(int pos, int v, int qv)
{
    del(pos);
    a[pos] = v;
    ins(pos);
    T2.change(0, n - 1, pos, 1);
    if (empty(T2.tr[1]))
    {
        int t = T2.query(0, n - 1, {0, inf}, 1);
        // printf("%d\n", t);
        pii val = t > 0 ? T2.get(0, n - 1, t - 1, 1) : make_pair(0, inf);
        return getans(qv, val);
    }
    pii val = T2.tr[1];
    if (val.pl == val.pr)
        return val.pl;
    int lid = *lac.rbegin(), rid = *rac.begin();
    int l = 0, r = L - 1, mid;
    while (l <= r)
    {
        mid = l + r >> 1;
        pii tmp = {lc[lid][mid], rc[rid][mid]};
        if (!empty(val + tmp))
            l = mid + 1;
        else
            r = mid - 1;
    }
    pii tmp = {lc[lid][r], rc[rid][r]};
    val = val + tmp;
    if (val.pl == val.pr || r == L - 1)
        return getans(qv, val);
    int t = T[r + 1].query(val, lid);
    if (t > 0)
        val = val + T[r + 1].get(0, n - 1, t - 1, T[r + 1].rt[lid]);
    t += (r + 1) * n;
    qv = getans(qv, make_pair(min(a[t % n], b[t % m]), max(a[t % n], b[t % m])));
    return getans(qv, val);
}
int main()
{
    scanf("%d %d %d", &n, &m, &q);
    for (int i = 0; i < n; i++)
        scanf("%d", &a[i]);
    for (int i = 0; i < m; i++)
        scanf("%d", &b[i]);
    prep();
    int ans = 0;
    while (q--)
    {
        int x, y, v;
        scanf("%d %d %d", &x, &y, &v);
        x = n - 1 - x;
        y ^= ans;
        v ^= ans;
        ans = update(x, y, v);
        printf("%d\n", ans);
    }
    return 0;
}