#include <bits/stdc++.h>
int prime[131072], nprime;
int min_factor[1500000];
void euler_sieve() {
  for (int i = 2; i < 1500000; ++i) {
    if (!min_factor[i]) prime[nprime++] = i, min_factor[i] = i;
    for (int j = 0; i * prime[j] < 1500000; ++j) {
      min_factor[i * prime[j]] = prime[j];
      if (i % prime[j] == 0) break;
    }
  }
  0;
}
struct TpRec {
  int base, hash;
  TpRec() {}
  TpRec(int _base, int _hash) : base(_base), hash(_hash) {}
};
TpRec tprec_merge(const TpRec &a, const TpRec &b) {
  int base = (long long int)a.base * b.base % 0x7fffffff,
      hash = ((long long int)a.hash * b.base + b.hash) % 0x7fffffff;
  return TpRec(base, hash);
}
struct Treap {
  static int cur_tm, n;
  static Treap pool[4194304], *head;
  static void init() {
    cur_tm = 0;
    head = &pool[0];
    for (int i = 0; i < 4194304; ++i) pool[i].tm = -1;
    for (int i = 0; i < 4194304 - 1; ++i) pool[i].r = &pool[i + 1];
    n = 4194304;
  }
  static void collect() {
    for (int i = 0; i < 4194304; ++i)
      if (pool[i].tm != -1 && pool[i].tm != cur_tm)
        pool[i].tm = -1, pool[i].r = head, head = &pool[i], ++n;
  }
  static Treap *alloc() {
    if (!head) return new Treap();
    Treap *res = head;
    head = head->r, --n;
    return res;
  }
  Treap *l, *r;
  TpRec v, s;
  int w, tm;
  Treap() {}
  Treap(const TpRec &_v) : l(0), r(0), v(_v), s(_v), w(1), tm(cur_tm) {}
  Treap(const TpRec &_v, Treap *_l, Treap *_r)
      : l(_l), r(_r), v(_v), s(_v), w(1), tm(cur_tm) {
    if (l) s = tprec_merge(l->s, s), w += l->w;
    if (r) s = tprec_merge(s, r->s), w += r->w;
  }
  void set_time() {
    tm = cur_tm;
    if (l) l->set_time();
    if (r) r->set_time();
  }
};
int Treap::cur_tm, Treap::n;
Treap Treap::pool[4194304], *Treap::head;
Treap *tp_split_l(Treap *p, int k) {
  if (!p) return 0;
  if (p->w == 0) return 0;
  if (p->w <= k) return p;
  int lw = p->l ? p->l->w : 0;
  return lw >= k ? tp_split_l(p->l, k)
                 : new (Treap::alloc())
                       Treap(p->v, p->l, tp_split_l(p->r, k - lw - 1));
}
Treap *tp_split_r(Treap *p, int k) {
  if (!p) return 0;
  if (p->w == 0) return p;
  if (p->w <= k) return 0;
  int lw = p->l ? p->l->w : 0;
  return lw >= k ? new (Treap::alloc()) Treap(p->v, tp_split_r(p->l, k), p->r)
                 : tp_split_r(p->r, k - lw - 1);
}
Treap *tp_merge(Treap *p, Treap *q) {
  if (!p || !q) return p ? p : q;
  return rand() % (p->w + q->w) < p->w
             ? new (Treap::alloc()) Treap(p->v, p->l, tp_merge(p->r, q))
             : new (Treap::alloc()) Treap(q->v, tp_merge(p, q->l), q->r);
}
struct Rec {
 public:
  Treap *l, *r;
  bool f;
  Rec() {}
  Rec(Treap *_l, Treap *_r) : l(_l), r(_r), f(0) {}
  Rec(bool _f) : l(0), r(0), f(_f) {}
  Rec(int k) : l(0), r(0), f(0) {
    if (k < 0)
      l = new (Treap::alloc()) Treap(TpRec(prime[-k], prime[-k]));
    else
      r = new (Treap::alloc()) Treap(TpRec(prime[k], prime[k]));
  }
};
Rec merge(const Rec &a, const Rec &b) {
  if (a.f || b.f) return Rec(true);
  int k = std::min(a.r ? a.r->w : 0, b.l ? b.l->w : 0);
  Treap *tl = tp_split_l(a.r, k), *tr = tp_split_l(b.l, k);
  if ((tl ? tl->s.hash : 0) != (tr ? tr->s.hash : 0)) return Rec(true);
  Treap *l = tp_merge(a.l, tp_split_r(b.l, k)),
        *r = tp_merge(b.r, tp_split_r(a.r, k));
  return Rec(l, r);
}
Rec rec[131072 * 2];
void build(int x = 1) {
  if (x >= 131072) return;
  build(x << 1), build(x << 1 | 1);
  rec[x] = merge(rec[x << 1], rec[x << 1 | 1]);
}
void change(Rec v, int k, int hl = 0, int hr = 131072, int x = 1) {
  if (x >= 131072) {
    assert(k == hl && hl == hr - 1);
    rec[x] = v;
    return;
  }
  int hm = hl + hr >> 1;
  change(v, k, k < hm ? hl : hm, k < hm ? hm : hr,
         k < hm ? x << 1 : x << 1 | 1);
  rec[x] = merge(rec[x << 1], rec[x << 1 | 1]);
}
Rec query(int l, int r, int hl = 0, int hr = 131072, int x = 1) {
  if (l <= hl && hr <= r) return rec[x];
  if (r <= hl || hr <= l) return Rec(false);
  int hm = hl + hr >> 1;
  return merge(query(l, r, hl, hm, x << 1), query(l, r, hm, hr, x << 1 | 1));
}
int main() {
  euler_sieve();
  Treap::init();
  int n;
  scanf("%d%*d", &n);
  for (int i = 0; i < n; ++i) {
    int k;
    scanf("%d", &k);
    rec[131072 + i] = Rec(k);
  }
  build();
  int q;
  scanf("%d", &q);
  for (int i = 0; i < q; ++i) {
    if (Treap::n < 256) {
      ++Treap::cur_tm;
      for (int i = 0; i < 131072 * 2; ++i) {
        if (rec[i].l) rec[i].l->set_time();
        if (rec[i].r) rec[i].r->set_time();
      }
      Treap::collect();
    }
    int ins;
    scanf("%d", &ins);
    if (ins == 1) {
      int x, k;
      scanf("%d%d", &x, &k), --x;
      change(Rec(k), x);
      continue;
    }
    if (ins == 2) {
      int l, r;
      scanf("%d%d", &l, &r), --l;
      Rec ret = query(l, r);
      puts(!ret.l && !ret.r && !ret.f ? "YES" : "NO");
      continue;
    }
    assert(false);
  }
  return 0;
}
