#include <bits/stdc++.h>
#ifdef dbg
#define D(...) fprintf(stderr, __VA_ARGS__)
#define DD(...) D("[Debug] "#__VA_ARGS__ " = "), \
              debug_helper::debug(__VA_ARGS__), D("\n")
#include "C:\Users\wsyear\Desktop\OI\templates\debug.hpp"
#else
#define D(...) ((void)0)
#define DD(...) ((void)0)
#endif
#define rep(i, j, k) for (int i = (j); i <= (k); ++i)
#define per(i, j, k) for (int i = (j); i >= (k); --i)
#define SZ(v) int((v).size())
#define ALL(v) (v).begin(),(v).end()
#define fi first
#define se second
using ll = long long;
using pii = std::pair<int, int>;
using pll = std::pair<ll, ll>;

template<class T> void chkmn(T &x, T y) { if (y < x) x = y; }
template<class T> void chkmx(T &x, T y) { if (y > x) x = y; }

using namespace std;

template <int P>
class mod_int {
  using Z = mod_int;

private:
  static int mo(int x) { return x < 0 ? x + P : x; }

public:
  int x;
  int val() const { return x; }
  mod_int() : x(0) {}
  template <class T>
  mod_int(const T &x_) : x(x_ >= 0 && x_ < P ? static_cast<int>(x_) : mo(static_cast<int>(x_ % P))) {}
  bool operator==(const Z &rhs) const { return x == rhs.x; }
  bool operator!=(const Z &rhs) const { return x != rhs.x; }
  Z operator-() const { return Z(x ? P - x : 0); }
  Z pow(long long k) const {
    Z res = 1, t = *this;
    while (k) {
      if (k & 1) res *= t;
      if (k >>= 1) t *= t;
    }
    return res;
  }
  Z &operator++() {
    x < P - 1 ? ++x : x = 0;
    return *this;
  }
  Z &operator--() {
    x ? --x : x = P - 1;
    return *this;
  }
  Z operator++(int) {
    Z ret = x;
    x < P - 1 ? ++x : x = 0;
    return ret;
  }
  Z operator--(int) {
    Z ret = x;
    x ? --x : x = P - 1;
    return ret;
  }
  Z inv() const { return pow(P - 2); }
  Z &operator+=(const Z &rhs) {
    (x += rhs.x) >= P && (x -= P);
    return *this;
  }
  Z &operator-=(const Z &rhs) {
    (x -= rhs.x) < 0 && (x += P);
    return *this;
  }
  Z &operator*=(const Z &rhs) {
    x = 1ULL * x * rhs.x % P;
    return *this;
  }
  Z &operator/=(const Z &rhs) { return *this *= rhs.inv(); }
#define setO(T, o)                                 \
  friend T operator o(const Z &lhs, const Z &rhs) {\
    Z res = lhs;                                   \
    return res o## = rhs;                          \
  }
  setO(Z, +) setO(Z, -) setO(Z, *) setO(Z, /)
#undef setO
};
const int P = 1011451423;
using Z = mod_int<P>;

const int maxn = 100010;
const Z base = 13331;
const Z ibase = base.inv();

Z pw[maxn], ipw[maxn];

struct segtree {
  
  struct node {
    int cnt, mx;
    Z sum;
    friend node operator+(node x, node y) {
      node res;
      res.cnt = x.cnt + y.cnt;
      res.mx = max(x.mx, y.mx);
      res.sum = x.sum * pw[y.cnt] + y.sum;
      return res;
    }
    friend node operator-(node x, node y) {
      node res;
      res.cnt = x.cnt - y.cnt;
      res.sum = (x.sum - y.sum) * ipw[y.cnt];
      return res;
    }
  } t[maxn << 2];
  
  #define mid ((l + r) >> 1)
  
  node qry(int c, int l, int r, int v) {
    if (l == r) {
      if (t[c].mx >= v) return t[c];
      return (node){0, 0, 0};
    }
    if (t[c << 1 | 1].mx >= v) return (t[c] - t[c << 1 | 1]) + qry(c << 1 | 1, mid + 1, r, v);
    else return qry(c << 1, l, mid, v);
  }
  
  void upd(int c, int l, int r, int x, int v) {
    if (l == r) return t[c] = (node){1, v, v}, void();
    if (x <= mid) upd(c << 1, l, mid, x, v);
    else upd(c << 1 | 1, mid + 1, r, x, v);
    t[c] = qry(c << 1, l, mid, t[c << 1 | 1].mx) + t[c << 1 | 1];
  }
  
  #undef mid
  
} t1, t2;

int n, m, q, a[maxn], b[maxn];

int main() {
  pw[0] = 1;
  rep (i, 1, maxn - 1) pw[i] = pw[i - 1] * base;
  ipw[0] = 1;
  rep (i, 1, maxn - 1) ipw[i] = ipw[i - 1] * ibase;
  cin.tie(nullptr) -> ios::sync_with_stdio(false);
  cin >> n;
  rep (i, 1, n) cin >> a[i];
  cin >> m;
  rep (i, 1, m) cin >> b[i];
  rep (i, 1, n) t1.upd(1, 1, n, i, a[i]);
  rep (i, 1, m) t2.upd(1, 1, m, i, b[i]);
  cin >> q;
  while (q--) {
    int op, x, y;
    cin >> op >> x >> y;
    if (op == 1) t1.upd(1, 1, n, x, y);
    else t2.upd(1, 1, m, x, y);
    cout << (t1.t[1].sum == t2.t[1].sum ? "YES" : "NO") << '\n';
  }
}