#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105000;
const int mod = (int)1e9 + 7;
const int p = 325849;
vector<long long> p1, p2;
int cLen = 0;
class Hashing {
 public:
  int n;
  vector<long long> h1, h2;
  void init(vector<int>& v) {
    n = (int)v.size();
    if (n == 0) return;
    int minChar = 0;
    h1.assign(n, 0);
    h2.assign(n, 0);
    h1[0] = v[0] - minChar + 1;
    h2[0] = (v[0] - minChar + 1) % mod;
    for (int i = 1; i < n; i++) {
      h1[i] = h1[i - 1] + p1[i] * (v[i] - minChar + 1);
      h2[i] = (h2[i - 1] + p2[i] * (v[i] - minChar + 1)) % mod;
    }
  }
  long long getHash1(int l, int r) {
    long long h = h1[r];
    if (l > 0) h -= h1[l - 1];
    h *= p1[cLen - 1 - r];
    return h;
  }
  long long getHash2(int l, int r) {
    long long h = h2[r];
    if (l > 0) h = (h - h2[l - 1] + mod) % mod;
    h = h * p2[cLen - 1 - r] % mod;
    return h;
  }
  pair<long long, long long> getHash(int l, int r) {
    return {getHash1(l, r), getHash2(l, r)};
  }
  pair<long long, long long> getHash() {
    return {getHash1(0, n - 1), getHash2(0, n - 1)};
  }
};
class Block {
 public:
  int l, r;
  Hashing close, open;
  bool bad;
  void init(int a[], int _l, int _r) {
    l = _l;
    r = _r;
    bad = false;
    recalc(a);
  }
  void recalc(int a[]) {
    vector<int> st;
    for (int i = l; i <= r; i++) {
      int cur = a[i];
      if (cur > 0)
        st.push_back(cur);
      else {
        if (!st.empty() && st.back() == -cur)
          st.pop_back();
        else
          st.push_back(cur);
      }
    }
    int pos = 0;
    while (pos < (int)st.size() && st[pos] < 0) pos++;
    while (pos < (int)st.size() && st[pos] > 0) pos++;
    if (pos != (int)st.size()) {
      bad = true;
      return;
    }
    vector<int> closeV, openV;
    pos = 0;
    while (pos < (int)st.size() && st[pos] < 0) {
      closeV.push_back(-st[pos]);
      pos++;
    }
    while (pos < (int)st.size()) {
      openV.push_back(st[pos]);
      pos++;
    }
    open.init(openV);
    reverse(closeV.begin(), closeV.end());
    close.init(closeV);
  }
};
class Piece {
 public:
  bool open;
  Hashing& h;
  int len;
  Piece(bool _open, Hashing& _h) : h(_h) {
    open = _open;
    len = _h.n;
  }
  pair<long long, long long> getHash(int needLen) {
    return h.getHash(len - needLen, len - 1);
  }
};
void initHashing(int n) {
  p1.assign(n + 1, 1);
  p2.assign(n + 1, 1);
  for (int i = 1; i <= n; i++) {
    p1[i] = p1[i - 1] * p;
    p2[i] = p2[i - 1] * p % mod;
  }
  cLen = n;
}
int n, tn;
Block blocks[MAXN];
int a[MAXN];
int bs = 0;
bool isGood(int l, int r) {
  vector<int> st;
  for (int i = l; i <= r; i++) {
    int cur = a[i];
    if (cur > 0)
      st.push_back(cur);
    else {
      if (!st.empty() && st.back() == -cur)
        st.pop_back();
      else
        return false;
    }
  }
  return (int)st.size() == 0;
}
vector<Piece> st;
void add(Piece& pc) {
  if (pc.open) {
    st.push_back(pc);
    return;
  }
  const bool need = !pc.open;
  while (pc.len > 0 && !st.empty() && st.back().open == need) {
    int backLen = st.back().len, curLen = pc.len;
    if (backLen < curLen) {
      if (st.back().getHash(backLen) == pc.getHash(backLen)) {
        pc.len -= st.back().len;
        st.pop_back();
      } else {
        break;
      }
    } else {
      if (st.back().getHash(curLen) == pc.getHash(curLen)) {
        st.back().len -= pc.len;
        if (st.back().len == 0) st.pop_back();
        pc.len = 0;
      } else {
        break;
      }
    }
  }
  if (pc.len > 0) st.push_back(pc);
}
void debug() {}
int main() {
  scanf("%d %d", &n, &tn);
  initHashing(n);
  for (int i = 0; i < n; i++) scanf("%d", &a[i]);
  bs = max(1, (int)sqrt(n));
  for (int i = 0;; i++) {
    int l = bs * i, r = min(l + bs - 1, n - 1);
    blocks[i].init(a, l, r);
    if (r == n - 1) break;
  }
  int qn;
  scanf("%d", &qn);
  while (qn--) {
    int type;
    scanf("%d", &type);
    if (type == 1) {
      int pos, val;
      scanf("%d %d", &pos, &val);
      pos--;
      a[pos] = val;
      int blockNum = pos / bs;
      int l = bs * blockNum, r = min(l + bs - 1, n - 1);
      blocks[blockNum].init(a, l, r);
    } else {
      int l, r;
      scanf("%d %d", &l, &r);
      l--;
      r--;
      if (r - l + 1 <= 2 * bs) {
        if (isGood(l, r))
          puts("Yes");
        else
          puts("No");
        continue;
      }
      int lBlock = l / bs, rBlock = r / bs;
      bool isBad = false;
      for (int i = lBlock + 1; i < rBlock; i++)
        if (blocks[i].bad) isBad = true;
      st.clear();
      Block bl;
      bl.init(a, l, min(bs * lBlock + bs - 1, n - 1));
      Block br;
      br.init(a, bs * rBlock, r);
      isBad |= (bl.bad || br.bad);
      if (isBad) {
        puts("No");
        continue;
      }
      if (bl.close.n != 0) {
        Piece pc(false, bl.close);
        st.push_back(pc);
      }
      if (bl.open.n != 0) {
        Piece pc(true, bl.open);
        st.push_back(pc);
      }
      debug();
      for (int i = lBlock + 1; i < rBlock; i++) {
        if (blocks[i].close.n != 0) {
          Piece pc(false, blocks[i].close);
          add(pc);
          debug();
        }
        if (blocks[i].open.n != 0) {
          Piece pc(true, blocks[i].open);
          add(pc);
          debug();
        }
      }
      if (br.close.n != 0) {
        Piece pc(false, br.close);
        add(pc);
      }
      if (br.open.n != 0) {
        Piece pc(true, br.open);
        add(pc);
      }
      debug();
      if (st.empty())
        puts("Yes");
      else
        puts("No");
    }
  }
  return 0;
}
