#include <bits/stdc++.h>

constexpr bool isprime(int n) {
    if (n <= 1) {
        return false;
    }
    for (int i = 2; i * i <= n; i++) {
        if (n % i == 0) {
            return false;
        }
    }
    return true;
}

constexpr int findPrime(int n) {
    while (!isprime(n)) {
        n++;
    }
    return n;
}

std::mt19937 rnd(std::chrono::high_resolution_clock::now().time_since_epoch().count());
const int P = findPrime(rnd() % 900000000 + 100000000);
const int B = rnd() % P;

constexpr int N = 100000;
int p[N + 1];

template <class Info>
struct SegmentTree {
#define m (l + r) / 2
    int n;
    std::vector<Info> tr;
    SegmentTree() : n(0) {}
    SegmentTree(int n_, Info v_ = Info()) {
        init(n_, v_);
    }
    template<class T>
    SegmentTree(std::vector<T> init_) {
        init(init_);
    }
    void init(int n_, Info v_ = Info()) {
        init(std::vector(n_, v_));
    }
    template<class T>
    void init(std::vector<T> init_) {
        n = init_.size();
        tr.assign(4 << std::__lg(n), Info());
        auto build = [&](auto&& self, int p, int l, int r) {
            if (r - l == 1) {
                tr[p] = init_[l];
                return;
            }
            self(self, 2 * p, l, m);
            self(self, 2 * p + 1, m, r);
            pull(p, m, r);
        };
        build(build, 1, 0, n);
    }

    void pull(int p, int bl, int br) {
        tr[p] = merge(tr[2 * p], tr[2 * p + 1], *this, bl, br);
    }

    void modify(int p, int l, int r, int x, const Info& v) {
        if (r - l == 1) {
            tr[p] = v;
            return;
        }
        if (x < m) {
            modify(2 * p, l, m, x, v);
        } else {
            modify(2 * p + 1, m, r, x, v);
        }
        pull(p, m, r);
    }
    void modify(int x, const Info& v) {
        modify(1, 0, n, x, v);
    }

    Info rangeQuery(int p, int l, int r, int x, int y) {
        if (l >= y || r <= x) {
            return Info();
        }
        if (l >= x && r <= y) {
            return tr[p];
        }
        return merge(rangeQuery(2 * p, l, m, x, y), rangeQuery(2 * p + 1, m, r, x, y), *this, m, r);
    }

    Info rangeQuery(int l, int r) {
        return rangeQuery(1, 0, n, l, r);
    }

    int find(int p, int l, int r, int x, int y, int v) {
        if (l >= y || r <= x || tr[p].max < v) {
            return -1;
        }
        if (r - l == 1) {
            return l;
        }
        int res = find(2 * p, l, m, x, y, v);
        if (res == -1) {
            res = find(2 * p + 1, m, r, x, y, v);
        }
        return res;
    }
    int find(int x, int y, int v) {
        return find(1, 0, n, x, y, v);
    }

#undef m
};

struct Info {
    int max;
    int hash;
    int siz;
    Info(int v = 0) : max(v), hash(1LL * v * B % P), siz(1) {}
};

Info merge(const Info& a, const Info& b, SegmentTree<Info>& seg, int bl, int br) {
    if (a.max == 0) {
        return b;
    } else if (b.max == 0) {
        return a;
    }
    if (a.max > b.max) {
        return a;
    }
    int pos = seg.find(bl, br, a.max);
    if (pos == -1) {
        pos = bl;
    }
    Info d = seg.rangeQuery(pos, br);
    Info c{};
    c.max = std::max(a.max, b.max);
    c.siz = a.siz + d.siz;
    c.hash = (a.hash + 1LL * d.hash * p[a.siz] % P) % P;
    return c;
}

int main() {
    p[0] = 1;
    for (int i = 1; i <= N; i++) {
        p[i] = (1LL * p[i - 1] * B) % P;
    }

    int n1;
    scanf("%d", &n1);
    std::vector<int> a(n1);
    for (int i = n1 - 1; i >= 0; i--) {
        scanf("%d", &a[i]);
    }

    int n2;
    scanf("%d", &n2);
    std::vector<int> b(n2);
    for (int i = n2 - 1; i >= 0; i--) {
        scanf("%d", &b[i]);
    }

    SegmentTree<Info> sega(a);
    SegmentTree<Info> segb(b);

    int m;
    for (scanf("%d", &m); m; m--) {
        int o, x, y;
        scanf("%d%d%d", &o, &x, &y);
        if (o == 1) {
            a.end()[-x] = y;
            sega.modify(n1 - x, y);
        } else {
            b.end()[-x] = y;
            segb.modify(n2 - x, y);
        }
        puts(sega.tr[1].hash == segb.tr[1].hash ? "YES" : "NO");
    }

    for (int i = 0; i < n1; i++) {
        for (int j = i; j < n1; j++) {
            int mx = 0;
            for (int k = i; k <= j; k++) {
                mx = std::max(mx, a[k]);
            }
            assert(mx == sega.rangeQuery(i, j + 1).max);
        }
    }
    for (int i = 0; i < n2; i++) {
        for (int j = i; j < n2; j++) {
            int mx = 0;
            for (int k = i; k <= j; k++) {
                mx = std::max(mx, b[k]);
            }
            assert(mx == segb.rangeQuery(i, j + 1).max);
        }
    }

    return 0;
}