#include <algorithm>
#include <cassert>
#include <cstdint>
#include <cstdio>
#include <iostream>
#include <string>

namespace {
using std::cin;
using std::cout;
using std::int64_t;

const int kP = 1.0e9 + 7;

namespace mod {
inline int FixDown(int x) { return x >= kP ? x - kP : x; }
inline int FixUp(int x) { return x + (x >> 31 & kP); }
inline void Add(int &x, int y) { x = FixDown(x + y); }
inline void Sub(int &x, int y) { x = FixUp(x - y); }
}  // namespace mod

struct Matrix {
  int a[2][2];
  Matrix() { a[0][0] = a[0][1] = a[1][0] = a[1][1] = 0; }

  Matrix(int a00, int a01, int a10, int a11) {
    a[0][0] = a00, a[0][1] = a01, a[1][0] = a10, a[1][1] = a11;
  }

  int operator()(int x, int y) const { return a[x][y]; }
  int &operator()(int x, int y) { return a[x][y]; }
};

bool operator==(const Matrix &a, const Matrix &b) {
  return a(0, 0) == b(0, 0) && a(0, 1) == b(0, 1) && a(1, 0) == b(1, 0) &&
         a(1, 1) == b(1, 1);
}

Matrix operator*(const Matrix &a, const Matrix &b) {
  Matrix ans;

  for (int i = 0; i < 2; ++i) {
    for (int j = 0; j < 2; ++j) {
      for (int k = 0; k < 2; ++k) {
        mod::Add(ans(i, k), int64_t{a(i, j)} * b(j, k) % kP);
      }
    }
  }

  return ans;
}

const Matrix kA[3] = {{55137393, 124721591, 516419127, 161648301},
                      {743364607, 275616217, 591343241, 413816712},
                      {955213219, 140433617, 882195051, 716407118}};

const Matrix kInvA[3] = {{55106935, 26982396, 538235082, 665987380},
                         {439606892, 814283157, 91200555, 49480163},
                         {913182781, 926757754, 659186055, 841996077}};

const Matrix kI = {1, 0, 0, 1};
const int kMaxN = 5.0e5 + 5;
int n, m;
std::string s;

namespace segment_tree {
const int kMaxM = kMaxN * 4;
int tag[kMaxM];
Matrix prod[kMaxM][3];

void PushUp(int p) {
  for (int i = 0; i < 3; ++i) {
    prod[p][i] = prod[p << 1][i] * prod[p << 1 | 1][i];
  }
}

void Build(int p, int l, int r) {
  if (l == r) {
    int x = s[l] - '0';

    if (l & 1) {
      for (int i = 0; i < 3; ++i) prod[p][i] = kInvA[(i + x) % 3];
    } else {
      for (int i = 0; i < 3; ++i) prod[p][i] = kA[(i + x) % 3];
    }

    return;
  }

  int mid = (l + r) >> 1;
  Build(p << 1, l, mid), Build(p << 1 | 1, mid + 1, r);
  PushUp(p);
}

void Build() { Build(1, 1, n); }

void ShiftAll(int p, int x) {
  std::rotate(prod[p], prod[p] + x % 3, prod[p] + 3);
  tag[p] += x;
}

void PushDown(int p) {
  if (!tag[p]) return;
  ShiftAll(p << 1, tag[p]), ShiftAll(p << 1 | 1, tag[p]);
  tag[p] = 0;
}

void Shift(int p, int l, int r, int L, int R) {
  if (L <= l && R >= r) {
    ShiftAll(p, 1);
    return;
  }

  int mid = (l + r) >> 1;
  PushDown(p);
  if (L <= mid) Shift(p << 1, l, mid, L, R);
  if (R > mid) Shift(p << 1 | 1, mid + 1, r, L, R);
  PushUp(p);
}

void Shift(int l, int r) { Shift(1, 1, n, l, r); }

Matrix Query(int p, int l, int r, int L, int R) {
  if (L <= l && R >= r) return prod[p][0];
  int mid = (l + r) >> 1;
  PushDown(p);
  if (R <= mid) return Query(p << 1, l, mid, L, R);
  if (L > mid) return Query(p << 1 | 1, mid + 1, r, L, R);
  return Query(p << 1, l, mid, L, R) * Query(p << 1 | 1, mid + 1, r, L, R);
}

Matrix Query(int l, int r) { return Query(1, 1, n, l, r); }
}  // namespace segment_tree
}  // namespace

int main() {
  cin.tie(nullptr);
  std::ios::sync_with_stdio(false);
  cin >> n >> m >> s, s = ' ' + s;
  segment_tree::Build();

  while (m--) {
    int op, l, r;
    cin >> op >> l >> r;

    if (op == 1) {
      segment_tree::Shift(l, r);
    } else {
      cout << (segment_tree::Query(l, r) == kI ? "Yes" : "No") << "\n";
    }
  }

  return 0;
}