#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());
constexpr int P = 998244353;
const int B = rnd() % P;

using u64 = uint64_t;

constexpr int N = 100000;
u64 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());
        std::function<void(int, int, int)> build = [&](int p, int l, int r) {
            if (r - l == 1) {
                tr[p] = init_[l];
                return;
            }
            build(2 * p, l, m);
            build(2 * p + 1, m, r);
            pull(p, m, r);
        };
        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;
    u64 hash;
    int siz;
    Info(int v = 0) : max(v), hash(1ULL * v * B), 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 + d.hash * p[a.siz];
    return c;
}

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

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

    int n1, n2, m;

    std::cin >> n1;
    std::vector<int> a(n1);
    for (int i = 0; i < n1; i++) {
        std::cin >> a[i];
    }

    std::cin >> n2;
    std::vector<int> b(n2);
    for (int i = 0; i < n2; i++) {
        std::cin >> b[i];
    }

    std::ranges::reverse(a);
    std::ranges::reverse(b);

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

    for (std::cin >> m; m; m--) {
        int o, x, y;
        std::cin >> o >> x >> y;
        if (o == 1) {
            sega.modify(n1 - x, y);
        } else {
            segb.modify(n2 - x, y);
        }
        std::cout << (sega.tr[1].hash == segb.tr[1].hash ? "YES" : "NO") << '\n';
    }

    return 0;
}