#include<bits/stdc++.h>

using namespace std;


constexpr int mod = 1e9 + 9;
constexpr int base = 133331;

void inc(int &x, int y) {
    x += y;
    if (x >= mod) x -= mod;
}
int add(int x, int y) {
    inc(x, y);
    return x;
}
int mul(int x, int y) {
    return 1ll * x * y % mod;
}

struct node {
    int cnt = 0;
    int max = 0;
    int hash = 0;
};

constexpr int MAXN = 2e5 + 5;
int pw[MAXN];

#define ls u * 2
#define rs u * 2 + 1
struct segtree {
    vector<node> tr;
    int n;

    segtree(int _n) : n(_n), tr(_n << 2) {}

    int find_First(int ql, int qr, int v, int l, int r, int u) {
        if (l > qr || r < ql || tr[u].max < v) {
            return -1;
        }
        if (l == r) return l;
        int m = l + r >> 1;
        int res = find_First(ql, qr, v, m + 1, r, rs);
        if (res == -1) {
            res = find_First(ql, qr, v, l, m, ls);
        }
        return res;
    }

    node get(int ql, int qr, int l, int r, int u) {
        if (ql <= l && r <= qr) {
            return tr[u];
        }
        int m = l + r >> 1;
        if (qr <= m) return get(ql, qr, l, m, ls);
        if (ql > m) return get(ql, qr, m + 1, r, rs);

        // auto L = get(ql, qr, l, m, ls);
        auto R = get(ql, qr, m + 1, r, rs);

        int pos = find_First(l, m, R.max, l, m, ls);
        if (pos < ql) {
            return R;
        }else {
            auto LL = get(ql, pos, l, m, ls);
            node c;
            c.cnt = LL.cnt + R.cnt;
            c.max = tr[ls].max;
            c.hash = add(mul(LL.hash, pw[R.cnt]), R.hash);
            return c;
        }
    }

    void modify(int x, int v, int l, int r, int u) {
        if (l == r) {
            tr[u] = {1, v, v};
            return;
        }
        int m = l + r >> 1;
        if (x <= m) modify(x, v, l, m, ls);
        else modify(x, v, m + 1, r, rs);

        int pos = find_First(l, m, tr[rs].max, l, m, ls);
        if (pos == -1) {
            tr[u] = tr[rs];
        }else {
            auto LL = get(l, pos, l, m, ls);
            tr[u].cnt = LL.cnt + tr[rs].cnt;
            tr[u].max = LL.max;
            tr[u].hash = add(mul(LL.hash, pw[tr[rs].cnt]), tr[rs].hash);
        }
    }
};
signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    pw[0] = 1;
    for (int i = 1; i < MAXN; i++) {
        pw[i] = mul(pw[i - 1], base);
    }

    int n1;
    cin >> n1;
    segtree st1(n1);
    for (int i = 1, x; i <= n1; i++) {
        cin >> x;
        st1.modify(i, x, 1, n1, 1);
    }
    int n2;
    cin >> n2;
    segtree st2(n2);
    for (int i = 1, x; i <= n2; i++) {
        cin >> x;
        st2.modify(i, x, 1, n2, 1);
    }

    int Q;
    cin >> Q;
    while (Q--) {
        int o, x, y;
        cin >> o >> x >> y;
        if (o == 1) {
            st1.modify(x, y, 1, n1, 1);
        }else {
            st2.modify(x, y, 1, n2, 1);
        }
        cout << (st1.tr[1].hash == st2.tr[1].hash ? "YES\n" : "NO\n");
    }

    return 0;
}