#include <bits/stdc++.h>
const int N = 1e5 + 10;
template <typename T>
inline T read() {
  T x(0);
  char ch = getchar();
  bool f(0);
  while (!isdigit(ch)) {
    f = ch == '-';
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = x * 10 + ch - '0';
    ch = getchar();
  }
  return f ? -x : x;
}
namespace H {
const int mod = 1e9 + 7, base = 20041222, ibase = 143924608;
int _w[N * 2], *w = _w + N;
void init(int sz) {
  w[0] = 1;
  for (int i = 1; i <= sz; ++i) {
    w[i] = (long long)w[i - 1] * base % mod;
    w[-i] = (long long)w[-i + 1] * ibase % mod;
  }
}
struct string {
  int len, val;
  string() { len = val = 0; }
  string(int x) { len = 1, val = x; }
  string(int _len, int _x) : len(_len), val(_x) {}
  bool operator==(const string &x) const {
    return this->len == x.len && this->val == x.val;
  }
};
string operator+(string a, string b) {
  return string(a.len + b.len, (a.val + (long long)b.val * w[a.len]) % mod);
}
string operator-(string a, string b) {
  return string(a.len - b.len,
                (long long)(a.val - b.val + mod) * w[-b.len] % mod);
}
}  // namespace H
using namespace H;
int n, k, a[N];
struct Node {
  string vl, vr;
  bool flag;
  int L, R;
} QS[N << 2];
inline int ls(int k) { return k << 1; }
inline int rs(int k) { return k << 1 | 1; }
string getl(int k, int len) {
  if (!len) return string();
  if (len == QS[k].vl.len) return QS[k].vl;
  if (len <= QS[ls(k)].vl.len) return getl(ls(k), len);
  return QS[ls(k)].vl +
         (getl(rs(k), len - QS[ls(k)].vl.len + QS[ls(k)].vr.len) -
          QS[ls(k)].vr);
}
string getr(int k, int len) {
  if (!len) return string();
  if (len == QS[k].vr.len) return QS[k].vr;
  if (len <= QS[rs(k)].vr.len) return getr(rs(k), len);
  return QS[rs(k)].vr +
         (getr(ls(k), len - QS[rs(k)].vr.len + QS[rs(k)].vl.len) -
          QS[rs(k)].vl);
}
void up(int k) {
  QS[k].flag = QS[ls(k)].flag | QS[rs(k)].flag;
  if (QS[k].flag) return;
  QS[k].vl = QS[ls(k)].vl;
  QS[k].vr = QS[rs(k)].vr;
  if (QS[ls(k)].vr.len <= QS[rs(k)].vl.len) {
    if (QS[ls(k)].vr == getl(rs(k), QS[ls(k)].vr.len))
      QS[k].vl = QS[k].vl + (QS[rs(k)].vl - QS[ls(k)].vr);
    else
      QS[k].flag = 1;
  } else {
    if (QS[rs(k)].vl == getr(ls(k), QS[rs(k)].vl.len))
      QS[k].vr = QS[k].vr + (QS[ls(k)].vr - QS[rs(k)].vl);
    else
      QS[k].flag = 1;
  }
}
void build(int k, int l, int r) {
  QS[k].L = l;
  QS[k].R = r;
  if (l == r) {
    if (a[l] > 0)
      QS[k].vr = string(a[l]);
    else
      QS[k].vl = string(-a[l]);
    return;
  }
  int mid((l + r) / 2);
  build(ls(k), l, mid);
  build(rs(k), mid + 1, r);
  up(k);
}
void modify(int k, int pos) {
  if (QS[k].L == QS[k].R) {
    QS[k].vl = QS[k].vr = string();
    if ((a[pos] = read<int>()) > 0)
      QS[k].vr = string(a[pos]);
    else
      QS[k].vl = string(-a[pos]);
    return;
  }
  int mid((QS[k].L + QS[k].R) / 2);
  modify(pos <= mid ? ls(k) : rs(k), pos);
  up(k);
}
int top, s[100];
string sq[100];
void find(int k, int l, int r) {
  if (l <= QS[k].L && QS[k].R <= r) {
    s[++top] = k;
    return;
  }
  int mid((QS[k].L + QS[k].R) / 2);
  if (l <= mid) find(ls(k), l, r);
  if (mid < r) find(rs(k), l, r);
}
string gtv(int pos, int len) {
  if (!len) return string();
  if (len == sq[pos].len) return sq[pos];
  if (len <= QS[s[pos]].vr.len) return getr(s[pos], len);
  return QS[s[pos]].vr +
         (gtv(pos - 1, len - QS[s[pos]].vr.len + QS[s[pos]].vl.len) -
          QS[s[pos]].vl);
}
bool query(int r, int l) {
  top = 0;
  find(1, l, r);
  for (int i = 1; i <= top; ++i) {
    if (QS[s[i]].flag) return 0;
    if (sq[i - 1].len < QS[s[i]].vl.len) return 0;
    if (QS[s[i]].vl == gtv(i - 1, QS[s[i]].vl.len))
      sq[i] = QS[s[i]].vr + (sq[i - 1] - QS[s[i]].vl);
    else
      return 0;
  }
  return !sq[top].len;
}
int main() {
  n = read<int>();
  k = read<int>();
  H::init(n);
  for (int i = 1; i <= n; ++i) a[i] = read<int>();
  build(1, 1, n);
  int q = read<int>();
  while (q--) {
    switch (read<int>()) {
      case 1: {
        modify(1, read<int>());
      } break;
      case 2: {
        puts(query(read<int>(), read<int>()) ? "Yes" : "No");
      } break;
    }
  }
  return 0;
}
