#include <cstdio>
#include <random>
#include <array>

const int N = 500005, S = 3;
const int Mod = 998244353;

using vec = std::array<int, 2>;
using mat = std::array<vec, 2>;

int pow(int a, int b, int ans = 1);
mat operator*(const mat &a, const mat &b) {
  mat res;
  res[0][0] = (1ll * a[0][0] * b[0][0] + 1ll * a[0][1] * b[1][0]) % Mod;
  res[0][1] = (1ll * a[0][0] * b[0][1] + 1ll * a[0][1] * b[1][1]) % Mod;
  res[1][0] = (1ll * a[1][0] * b[0][0] + 1ll * a[1][1] * b[1][0]) % Mod;
  res[1][1] = (1ll * a[1][0] * b[0][1] + 1ll * a[1][1] * b[1][1]) % Mod;
  return res;
}

namespace Seg {
mat prod[N << 2][3];
int tag[N << 2];

void build(int x, int xl, int xr);
void update(int x, int xl, int xr, int ul, int ur);
mat query(int x, int xl, int xr, int ql, int qr);
}

char ch[N];
std::mt19937 rnd(std::random_device{}());
std::uniform_int_distribution <int> D(1, Mod - 1);
mat mi[N][3];
mat m[3][2];

int main() {
  for (int i = 0; i < S; ++i) {
    while (true) {
      mat &odd = m[i][0];
      odd[0][0] = D(rnd), odd[0][1] = D(rnd), odd[1][0] = D(rnd), odd[1][1] = D(rnd);
      int det = ((1ll * odd[0][0] * odd[1][1] - 1ll * odd[1][0] * odd[0][1]) % Mod + Mod) % Mod;
      if (det == 0) continue;
      int iv = pow(det, Mod - 2);
      mat &even = m[i][1];
      even[0][0] = 1ll * odd[1][1] * iv % Mod;
      even[0][1] = 1ll * (Mod - odd[0][1]) * iv % Mod;
      even[1][0] = 1ll * (Mod - odd[1][0]) * iv % Mod;
      even[1][1] = 1ll * odd[0][0] * iv % Mod;
      break;
    }
  }
  int n, q;
  scanf("%d %d", &n, &q);
  scanf("%s", ch + 1);
  for (int i = 1; i <= n; ++i) {
    int v = ch[i] - '0';
    for (int j = 0; j < S; ++j)
      mi[i][j] = m[(j + v) % 3][i & 1];
  }
  Seg::build(1, 1, n);
  while (q--) {
    int id, l, r;
    scanf("%d %d %d", &id, &l, &r);
    if (id == 1) {
      Seg::update(1, 1, n, l, r);
    } else {
      mat ans = Seg::query(1, 1, n, l, r);
      if (ans[0][0] == 1 && ans[1][1] == 1 && ans[0][1] == 0 && ans[1][0] == 0) {
        puts("Yes");
      } else {
        puts("No");
      }
    }
  }
  return 0;
}

namespace Seg {
void upd(int x) {
  for (int i = 0; i < S; ++i)
    prod[x][i] = prod[x << 1][i] * prod[x << 1 | 1][i];
}
void add(int x, int t) {
  tag[x] += t;
  mat las[3] = {prod[x][0], prod[x][1], prod[x][2]};
  for (int i = 0; i < S; ++i)
    prod[x][i] = las[(i + t) % 3];
}
void pushdown(int x) {
  if (tag[x]) {
    add(x << 1, tag[x]);
    add(x << 1 | 1, tag[x]);
    tag[x] = 0;
  }
}
void build(int x, int xl, int xr) {
  tag[x] = 0;
  if (xl == xr) {
    for (int i = 0; i < S; ++i)
      prod[x][i] = mi[xl][i];
    return;
  }
  int xm = (xl + xr) >> 1;
  build(x << 1, xl, xm), build(x << 1 | 1, xm + 1, xr);
  upd(x);
}
void update(int x, int xl, int xr, int ul, int ur) {
  if (ul <= xl && xr <= ur) {
    add(x, 1);
    return;
  }
  pushdown(x);
  int xm = (xl + xr) >> 1;
  if (ul <= xm) update(x << 1, xl, xm, ul, ur);
  if (ur > xm) update(x << 1 | 1, xm + 1, xr, ul, ur);
  upd(x);
}
mat query(int x, int xl, int xr, int ql, int qr) {
  if (ql <= xl && xr <= qr) {
    return prod[x][0];
  }
  pushdown(x);
  int xm = (xl + xr) >> 1;
  mat e;
  e[0][0] = e[1][1] = 1, e[1][0] = e[0][1] = 0;
  if (ql <= xm) e = e * query(x << 1, xl, xm, ql, qr);
  if (qr > xm) e = e * query(x << 1 | 1, xm + 1, xr, ql, qr);
  return e;
}
}

int pow(int a, int b, int ans) {
  while (b) {
    if (b & 1) ans = 1ll * ans * a % Mod;
    a = 1ll * a * a % Mod;
    b >>= 1;
  }
  return ans;
}