#include <bits/stdc++.h>
using namespace std;
const pair<int, int> MOD = make_pair(1e9 + 7, 1e9 + 9);
const int base = 1e6 + 3;
const int N = 1e5 + 100, B = 600;
pair<int, int> operator+(pair<int, int> a, pair<int, int> b) {
  return make_pair((a.first + b.first) % MOD.first,
                   (a.second + b.second) % MOD.second);
}
pair<int, int> operator-(pair<int, int> a, pair<int, int> b) {
  return make_pair((a.first - b.first + MOD.first) % MOD.first,
                   (a.second - b.second + MOD.second) % MOD.second);
}
pair<int, int> operator*(pair<int, int> a, int x) {
  return make_pair(1ll * a.first * x % MOD.first,
                   1ll * a.second * x % MOD.second);
}
pair<int, int> operator*(pair<int, int> a, pair<int, int> b) {
  return make_pair(1ll * a.first * b.first % MOD.first,
                   1ll * a.second * b.second % MOD.second);
}
int n, K, q;
int a[N];
vector<pair<int, int>> open_Hash[B], close_Hash[B];
pair<int, int> base_pow[N], inv_pow[N];
int good[N];
int bm(int b, int p, int m) {
  if (p == 0) return 1;
  int t = bm(b, p / 2, m);
  t = 1ll * t * t % m;
  if (p & 1) return 1ll * b * t % m;
  return t;
}
void pre() {
  base_pow[0] = {1, 1};
  inv_pow[0] = {1, 1};
  for (int i = 1; i < N; i++) {
    base_pow[i] = base_pow[i - 1] * base;
    inv_pow[i].first = bm(base_pow[i].first, MOD.first - 2, MOD.first);
    inv_pow[i].second = bm(base_pow[i].second, MOD.second - 2, MOD.second);
  }
}
bool recal(int l, int r, vector<pair<int, int>> &close,
           vector<pair<int, int>> &open) {
  vector<int> stk;
  for (int i = l; i <= r; i++) {
    if (a[i] < 0 && stk.size() > 0 && stk.back() == abs(a[i]))
      stk.pop_back();
    else
      stk.push_back(a[i]);
  }
  close.clear();
  open.clear();
  bool pos = false;
  for (int i = 0; i < stk.size(); i++) {
    if (stk[i] > 0) pos = true;
    if (stk[i] < 0 && pos) return false;
  }
  for (int i = 0; i < stk.size(); i++) {
    if (stk[i] > 0) break;
    int x = abs(stk[i]);
    int kth = close.size();
    close.push_back(base_pow[kth] * x);
  }
  for (int i = 1; i < close.size(); i++) {
    close[i] = close[i - 1] + close[i];
  }
  for (int i = (int)stk.size() - 1; i >= 0; i--) {
    if (stk[i] < 0) break;
    int x = abs(stk[i]);
    int kth = open.size();
    open.push_back(base_pow[kth] * x);
  }
  for (int i = 1; i < open.size(); i++) {
    open[i] = open[i - 1] + open[i];
  }
  return true;
}
bool find_hash(vector<pair<int, int>> &all_open, int sz, pair<int, int> hhh) {
  assert(sz > 0);
  int psz = 0;
  pair<int, int> h = {0, 0};
  while (psz < sz && all_open.size() > 0) {
    auto t = all_open.back();
    all_open.pop_back();
    int which_block = t.first, idx = t.second;
    int cur_sz = open_Hash[which_block].size() - idx;
    assert(cur_sz > 0);
    if (cur_sz + psz < sz) {
      pair<int, int> hh =
          (open_Hash[which_block].back() -
           (idx > 0 ? open_Hash[which_block][idx - 1] : make_pair(0, 0))) *
          inv_pow[idx];
      hh = hh * base_pow[psz];
      h = h + hh;
      psz += cur_sz;
    } else {
      int lage = sz - psz;
      pair<int, int> hh =
          (open_Hash[which_block][idx + lage - 1] -
           (idx > 0 ? open_Hash[which_block][idx - 1] : make_pair(0, 0))) *
          inv_pow[idx];
      hh = hh * base_pow[psz];
      h = h + hh;
      if (idx + lage < open_Hash[which_block].size())
        all_open.push_back({which_block, idx + lage});
      psz += lage;
    }
  }
  if (psz < sz) return 0;
  if (hhh != h) return 0;
  return 1;
}
int query(int l, int r) {
  int bl = l / B, br = r / B;
  if (bl == br) {
    vector<pair<int, int>> p, s;
    int x = recal(l, r, p, s);
    if (x && (int)p.size() == 0 && (int)s.size() == 0) return 1;
    return 0;
  }
  if (recal(l, (bl + 1) * B - 1, close_Hash[B - 2], open_Hash[B - 2]) == 0)
    return 0;
  if (close_Hash[B - 2].size() > 0) return 0;
  vector<pair<int, int>> all_open;
  if (open_Hash[B - 2].size() > 0) all_open.push_back({B - 2, 0});
  for (int b = bl + 1; b < br; b++) {
    if (!good[b]) return 0;
    if (close_Hash[b].size() == 0) {
      if (open_Hash[b].size() > 0) all_open.push_back({b, 0});
      continue;
    }
    int sz = close_Hash[b].size();
    if (!find_hash(all_open, sz, close_Hash[b].back())) return 0;
    if (open_Hash[b].size() > 0) all_open.push_back({b, 0});
  }
  if (recal(br * B, r, close_Hash[B - 1], open_Hash[B - 1]) == 0) return 0;
  if (open_Hash[B - 1].size() > 0) return 0;
  if (close_Hash[B - 1].size() > 0 &&
      !find_hash(all_open, close_Hash[B - 1].size(), close_Hash[B - 1].back()))
    return 0;
  if (all_open.size() > 0) return 0;
  return 1;
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  pre();
  cin >> n >> K;
  for (int i = 0; i < n; i++) cin >> a[i];
  for (int i = 0, j = 0; i < n; i += B, j++) {
    good[j] = recal(i, min(i + B - 1, n - 1), close_Hash[j], open_Hash[j]);
  }
  int q;
  cin >> q;
  while (q--) {
    int t;
    cin >> t;
    if (t == 1) {
      int idx, x;
      cin >> idx >> x;
      idx--;
      a[idx] = x;
      int b = idx / B;
      int l = b * B, r = min(l + B - 1, n - 1);
      good[b] = recal(l, r, close_Hash[b], open_Hash[b]);
    } else {
      int l, r;
      cin >> l >> r;
      l--, r--;
      if (query(l, r))
        cout << "Yes" << endl;
      else
        cout << "No" << endl;
    }
  }
  return 0;
}
