#include <bits/stdc++.h>
using namespace std;
inline char nc() {
  static char buf[100000], *l = buf, *r = buf;
  return l == r && (r = (l = buf) + fread(buf, 1, 100000, stdin), l == r)
             ? EOF
             : *l++;
}
template <class T>
void read(T &x) {
  x = 0;
  int f = 1, ch = nc();
  while (ch < '0' || ch > '9') {
    if (ch == '-') f = -1;
    ch = nc();
  }
  while (ch >= '0' && ch <= '9') {
    x = x * 10 - '0' + ch;
    ch = nc();
  }
  x *= f;
}
const int maxn = 1e5 + 50;
const int base = 87341;
const int mod = 1004535809;
int n, k, q;
int s[maxn];
int pw[maxn];
int rp[maxn];
inline int sub(int x) { return x < 0 ? x + mod : x; }
long long power(long long x, long long y) {
  long long re = 1;
  while (y) {
    if (y & 1) re = re * x % mod;
    x = x * x % mod;
    y >>= 1;
  }
  return re;
}
inline int calc(int x) { return x >= 0 ? pw[x] : rp[-x]; }
namespace seg {
const int maxnode = maxn << 2;
struct node {
  int a, la, b, lb;
  node(int a = 0, int la = 0, int b = 0, int lb = 0)
      : a(a), la(la), b(b), lb(lb) {}
} tree[maxnode];
int Qa(int u, int l, int r, int k) {
  if (k == 0) return 0;
  if (l == r) {
    return tree[u].a;
  }
  int mid = (l + r) >> 1;
  if (tree[u << 1].a == -1) return Qa(u << 1, l, mid, k);
  if (k <= tree[u << 1].la)
    return Qa(u << 1, l, mid, k);
  else {
    int re = Qa(u << 1 | 1, mid + 1, r, k - tree[u << 1].la + tree[u << 1].lb);
    re = (tree[u << 1].a + (long long)calc(tree[u << 1].la - tree[u << 1].lb) *
                               sub(re - tree[u << 1].b)) %
         mod;
    return re;
  }
}
int Qb(int u, int l, int r, int k) {
  if (k == 0) return 0;
  if (l == r) {
    return tree[u].b;
  }
  int mid = (l + r) >> 1;
  if (tree[u << 1 | 1].a == -1) return Qb(u << 1 | 1, mid + 1, r, k);
  if (k <= tree[u << 1 | 1].lb)
    return Qb(u << 1 | 1, mid + 1, r, k);
  else {
    int re = Qb(u << 1, l, mid, k - tree[u << 1 | 1].lb + tree[u << 1 | 1].la);
    re = (tree[u << 1 | 1].b +
          (long long)calc(tree[u << 1 | 1].lb - tree[u << 1 | 1].la) *
              sub(re - tree[u << 1 | 1].a)) %
         mod;
    return re;
  }
}
inline node merge(node L, node R, int u, int l, int r) {
  if (L.a == -1 || R.a == -1) return node(-1);
  int mid = (l + r) >> 1;
  int d = min(L.lb, R.la);
  L.lb -= d, R.la -= d;
  int t = 0;
  if ((t = Qb(u << 1, l, mid, d)) != Qa(u << 1 | 1, mid + 1, r, d))
    return node(-1);
  if (L.lb == 0)
    return node((L.a + (long long)calc(L.la - d) * sub(R.a - t)) % mod,
                L.la + R.la, R.b, R.lb);
  else
    return node(L.a, L.la,
                (R.b + (long long)calc(R.lb - d) * sub(L.b - t)) % mod,
                R.lb + L.lb);
}
void build(int u, int l, int r) {
  if (l == r) {
    tree[u] = s[l] > 0 ? node(0, 0, s[l], 1) : node(-s[l], 1, 0, 0);
    return;
  }
  int mid = (l + r) >> 1;
  build(u << 1, l, mid);
  build(u << 1 | 1, mid + 1, r);
  tree[u] = merge(tree[u << 1], tree[u << 1 | 1], u, l, r);
}
void update(int u, int l, int r, int qp, int qv) {
  if (l == r) {
    tree[u] = qv > 0 ? node(0, 0, qv, 1) : node(-qv, 1, 0, 0);
    return;
  }
  int mid = (l + r) >> 1;
  if (qp <= mid)
    update(u << 1, l, mid, qp, qv);
  else
    update(u << 1 | 1, mid + 1, r, qp, qv);
  tree[u] = merge(tree[u << 1], tree[u << 1 | 1], u, l, r);
}
node query(int u, int l, int r, int ql, int qr) {
  if (l == ql && r == qr) {
    return tree[u];
  }
  int mid = (l + r) >> 1;
  if (qr <= mid)
    return query(u << 1, l, mid, ql, qr);
  else if (ql > mid)
    return query(u << 1 | 1, mid + 1, r, ql, qr);
  else {
    node L = query(u << 1, l, mid, ql, mid);
    node R = query(u << 1 | 1, mid + 1, r, mid + 1, qr);
    return merge(L, R, u, l, r);
  }
}
bool sol(int l, int r) {
  node an = query(1, 1, n, l, r);
  return an.a != -1 && an.la == 0 && an.lb == 0;
}
}  // namespace seg
void init() {
  pw[0] = 1;
  for (int i = 1; i <= n; ++i) pw[i] = (long long)pw[i - 1] * base % mod;
  rp[n] = power(pw[n], mod - 2);
  for (int i = n; i >= 1; --i) rp[i - 1] = (long long)rp[i] * base % mod;
}
int main() {
  read(n), read(k);
  for (int i = 1; i <= n; ++i) read(s[i]);
  init();
  seg::build(1, 1, n);
  read(q);
  for (int i = 1; i <= q; ++i) {
    int op;
    read(op);
    if (op == 1) {
      int x, t;
      read(x), read(t);
      seg::update(1, 1, n, x, t);
    } else if (op == 2) {
      int l, r;
      read(l), read(r);
      puts(seg::sol(l, r) ? "Yes" : "No");
    }
  }
  return 0;
}
