#include <bits/stdc++.h>
using namespace std;
using LL = long long;
using UL = unsigned long long;
const UL mi = 1e9 + 7;
const int N = 1e5 + 10;

UL m995[N], a[N], b[N];
struct tree {
    int l, r;
    UL cnt;
    UL max, hs, minstk;
    friend tree operator + (tree &a, tree &b) {
        tree ans;
        ans.cnt = a.cnt + b.cnt;
        ans.minstk = a.minstk;
        if(!a.minstk) ans.minstk = b.minstk;
        if(a.max > b.max) ans.max = a.max;
        else ans.max = b.max;
        ans.hs = a.hs * m995[b.cnt] + b.hs;
        return ans;
    }
}A[N << 3], B[N << 3], nul;

tree ask(int p, UL mx, int ty) 
{
    if(!ty) {
        if(!A[p].l || A[p].max < mx) return nul;
        if(A[p].minstk >= mx) return A[p];
        tree tmp = ask(p * 2, mx, ty);
        tree tmp2 = ask(p * 2 + 1, max(tmp.max, mx), ty);
        return tmp + tmp2;
    }

    else {
        if(!B[p].l || B[p].max < mx) return nul;
        if(B[p].minstk >= mx) return B[p];
        tree tmp = ask(p * 2, mx, ty);
        tree tmp2 = ask(p * 2 + 1, max(tmp.max, mx), ty);
        return tmp + tmp2;
    }
}


void update(int p, int ty)
{
    int ls = p * 2, rs = p * 2 + 1;
    if(!ty) {
        if(A[ls].max > A[rs].max) {
            A[p].cnt = A[ls].cnt;
            A[p].hs = A[ls].hs;
            A[p].max = A[ls].max;
            A[p].minstk = A[ls].minstk;
        }
        else {
            tree tmp;
            if(A[ls].max <= A[rs].minstk) tmp = A[rs];
            else tmp = ask(rs, A[ls].max, ty);
            
            tmp = A[ls] + tmp;
            A[p].cnt = tmp.cnt;
            A[p].hs = tmp.hs;
            A[p].max = tmp.max;
            A[p].minstk = tmp.minstk;
        }
    }

    else {
        if(B[ls].max > B[rs].max) {
            B[p].cnt = B[ls].cnt;
            B[p].hs = B[ls].hs;
            B[p].max = B[ls].max;
            B[p].minstk = B[ls].minstk;
        }
        else {
            tree tmp;
            if(B[ls].max <= B[rs].minstk) tmp = B[rs];
            else tmp = ask(rs, B[ls].max, ty);

            tmp = B[ls] + tmp;
            B[p].cnt = tmp.cnt;
            B[p].hs = tmp.hs;
            B[p].max = tmp.max;
            B[p].minstk = tmp.minstk;
        }
    }
}

void build(int l, int r, int p, int ty) 
{
    if(!ty) {
        A[p].l = l, A[p].r = r;
        if(l == r) {
            A[p].cnt = 1;
            A[p].max = A[p].hs = A[p].minstk = a[l];
            return;
        }
    }
    else {
        B[p].l = l, B[p].r = r;
        if(l == r) {
            B[p].cnt = 1;
            B[p].max = B[p].hs = B[p].minstk = b[l];
            return;
        }
    }
    int mid = l + r >> 1;
    build(l, mid, p * 2, ty);
    build(mid + 1, r, p * 2 + 1, ty);
    update(p, ty);
}

void change(int x, int p, UL To, int ty)
{
    if(!ty) {
        if(A[p].l == A[p].r && A[p].l == x) {
            A[p].hs = A[p].max = A[p].minstk = To;
            return;
        }

        int mid = A[p].l + A[p].r >> 1;
        if(x <= mid) change(x, p * 2, To, ty);
        else change(x, p * 2 + 1, To, ty);
        update(p, ty);
    }

    else {
        if(B[p].l == B[p].r && B[p].l == x) {
            B[p].hs = B[p].max = B[p].minstk = To;
            return;
        }

        int mid = B[p].l + B[p].r >> 1;
        if(x <= mid) change(x, p * 2, To, ty);
        else change(x, p * 2 + 1, To, ty);
        update(p, ty);
    }
}

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

    m995[0] = 1;
    for(int i = 1; i < N; i++) m995[i] = m995[i - 1] * mi;
    int n, m, q;
    cin >> n;
    for(int i = n; i >= 1; i--) cin >> a[i];
    cin >> m;
    for(int i = m; i >= 1; i--) cin >> b[i];
    build(1, n, 1, 0);
    build(1, m, 1, 1);

    int op, x, y;
    cin >> q;
    for(int i = 1; i <= q; i++) {
        cin >> op >> x >> y;
        if(op == 1) x = n - x + 1, change(x, 1, y, 0);
        if(op == 2) x = m - x + 1, change(x, 1, y, 1);
        if(B[1].hs == A[1].hs) cout << "YES\n";
        else cout << "NO\n"; 
    }

}