#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 5, B = 233333, mod = 819657149;
long long ksm(long long b, long long n) {
  long long res = 1;
  while (n) {
    if (n & 1) res = 1ll * res * b % mod;
    b = 1ll * b * b % mod;
    n >>= 1;
  }
  return res;
}
long long inv_pw[N], pw[N];
void init(long long n) {
  pw[0] = inv_pw[0] = 1;
  inv_pw[1] = ksm(B, mod - 2);
  for (long long i = 1; i <= n; ++i) pw[i] = 1ll * pw[i - 1] * B % mod;
  for (long long i = 2; i <= n; ++i)
    inv_pw[i] = 1ll * inv_pw[i - 1] * inv_pw[1] % mod;
}
struct Segment_Tree {
  long long fl;
  long long Hash_l, Hash_r;
  long long cnt_l, cnt_r;
  long long lson, rson;
  Segment_Tree() { fl = Hash_l = cnt_l = cnt_r = lson = rson = 0; }
  Segment_Tree(long long x) {
    fl = 1;
    if (x > 0) {
      cnt_l = Hash_l = 0;
      cnt_r = 1;
      Hash_r = x;
    } else {
      cnt_l = 1;
      Hash_l = (mod + x >= mod ? mod + x - mod : mod + x);
      cnt_r = Hash_r = 0;
    }
  }
} tr[N << 2];
long long GetHashL(long long p, long long len) {
  if (!len) return 0;
  if (tr[p].cnt_l == len) return tr[p].Hash_l;
  if (len <= tr[tr[p].lson].cnt_l)
    return GetHashL(tr[p].lson, len);
  else {
    long long t =
        GetHashL(tr[p].rson, len - tr[tr[p].lson].cnt_l + tr[tr[p].lson].cnt_r);
    t = 1ll * (t + tr[tr[p].lson].Hash_r) % mod * inv_pw[tr[tr[p].lson].cnt_r] %
        mod;
    return (1ll * t * pw[tr[tr[p].lson].cnt_l] % mod + tr[tr[p].lson].Hash_l) %
           mod;
  }
}
long long GetHashR(long long p, long long len) {
  if (!len) return 0;
  if (tr[p].cnt_r == len) return tr[p].Hash_r;
  if (len <= tr[tr[p].rson].cnt_r)
    return GetHashR(tr[p].rson, len);
  else {
    long long t =
        GetHashR(tr[p].lson, len - tr[tr[p].rson].cnt_r + tr[tr[p].rson].cnt_l);
    t = 1ll * (t + tr[tr[p].rson].Hash_l) % mod * inv_pw[tr[tr[p].rson].cnt_l] %
        mod;
    return (1ll * t * pw[tr[tr[p].rson].cnt_r] % mod + tr[tr[p].rson].Hash_r) %
           mod;
  }
}
void pushup(long long u, long long lc, long long rc) {
  tr[u].lson = lc;
  tr[u].rson = rc;
  tr[u].fl = tr[lc].fl & tr[rc].fl;
  if (!tr[u].fl) return;
  if (tr[lc].cnt_r <= tr[rc].cnt_l) {
    if ((tr[lc].Hash_r + GetHashL(rc, tr[lc].cnt_r)) % mod == 0) {
      long long t = 1ll * (tr[lc].Hash_r + tr[rc].Hash_l) % mod *
                    inv_pw[tr[lc].cnt_r] % mod;
      tr[u].cnt_l = tr[rc].cnt_l - tr[lc].cnt_r + tr[lc].cnt_l;
      tr[u].Hash_l = (1ll * t * pw[tr[lc].cnt_l] % mod + tr[lc].Hash_l) % mod;
      tr[u].cnt_r = tr[rc].cnt_r;
      tr[u].Hash_r = tr[rc].Hash_r;
    } else
      tr[u].fl = 0;
  } else {
    if ((tr[rc].Hash_l + GetHashR(lc, tr[rc].cnt_l)) % mod == 0) {
      long long t = 1ll * (tr[lc].Hash_r + tr[rc].Hash_l) % mod *
                    inv_pw[tr[rc].cnt_l] % mod;
      tr[u].cnt_l = tr[lc].cnt_l;
      tr[u].Hash_l = tr[lc].Hash_l;
      tr[u].cnt_r = tr[lc].cnt_r - tr[rc].cnt_l + tr[rc].cnt_r;
      tr[u].Hash_r = (1ll * t * pw[tr[rc].cnt_r] % mod + tr[rc].Hash_r) % mod;
    } else
      tr[u].fl = 0;
  }
}
void upt(long long p, long long l, long long r, long long pos, long long x) {
  if (l == r) return (void)(tr[p] = x);
  long long mid = (l + r) >> 1;
  if (pos <= mid)
    upt(tr[p].lson, l, mid, pos, x);
  else
    upt(tr[p].rson, mid + 1, r, pos, x);
  pushup(p, tr[p].lson, tr[p].rson);
}
long long cnt, ans;
long long query(long long p, long long l, long long r, long long ql,
                long long qr) {
  if (ql <= l && r <= qr) return p;
  long long mid = (l + r) >> 1;
  if (mid < ql) return query(tr[p].rson, mid + 1, r, ql, qr);
  if (qr <= mid) return query(tr[p].lson, l, mid, ql, qr);
  long long lc = query(tr[p].lson, l, mid, ql, qr),
            rc = query(tr[p].rson, mid + 1, r, ql, qr);
  ++cnt;
  pushup(cnt, lc, rc);
  return cnt;
}
inline long long rd() {
  long long x = 0;
  char ch = getchar();
  bool f = 0;
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = 1;
  for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
  return f ? -x : x;
}
void build(long long p, long long l, long long r) {
  tr[p].lson = (p << 1);
  tr[p].rson = (p << 1 | 1);
  if (l == r) return (void)(tr[p] = rd());
  long long mid = (l + r) >> 1;
  build(tr[p].lson, l, mid);
  build(tr[p].rson, mid + 1, r);
  pushup(p, tr[p].lson, tr[p].rson);
}
signed main() {
  long long n, k;
  n = rd(), k = rd();
  init(n);
  build(1, 1, n);
  long long Q = rd();
  while (Q--) {
    long long opt, l, r;
    opt = rd(), l = rd(), r = rd();
    if (opt == 1)
      upt(1, 1, n, l, r);
    else {
      cnt = n << 4;
      ans = query(1, 1, n, l, r);
      if (tr[ans].cnt_l == 0 && tr[ans].cnt_r == 0 && tr[ans].fl == 1)
        puts("Yes");
      else
        puts("No");
    }
  }
  return 0;
}
