// 
#include <bits/stdc++.h>
using namespace std;
#define debug(...) fprintf (stderr, __VA_ARGS__)

typedef long long ll;
typedef __int128 i128;

#define fi first
#define se second
#define lep(i, l, r) for (int i = (l), i##_end = (r); i <= i##_end; ++ i)
#define rep(i, r, l) for (int i = (r), i##_end = (l); i >= i##_end; -- i)

char _c; bool _f; template <class T> inline void IN (T & x) {
	x = 0, _f = 0; while (_c = getchar (), ! isdigit (_c)) if (_c == '-') _f = 1;
	while (isdigit (_c)) x = x * 10 + _c - '0', _c = getchar (); if (_f) x = - x;
}

const int mod = 998244353;
const int inv2 = (mod + 1) >> 1;

inline int mul (int x, int y) { return 1ll * x * y % mod; }
inline int qpow (int x, int y, int r = 1) { for ( ; y; y >>= 1, x = mul (x, x)) if (y & 1) r = mul (r, x); return r; }

inline void sub (int &x, int y) { x -= y; if (x < 0) x += mod; }
inline void pls (int &x, int y) { x += y; if (x >= mod) x -= mod; }

inline int dec (int x, int y) { x -= y; if (x < 0) x += mod; return x; }
inline int add (int x, int y) { x += y; if (x >= mod) x -= mod; return x; }

template <class T> inline void chkmin (T & x, T y) { if (x > y) x = y; }
template <class T> inline void chkmax (T & x, T y) { if (x < y) x = y; }

mt19937 seed (time (0));
uniform_int_distribution <> rnd (0, mod - 1);

// {{{ matrix

const int K = 2;
#define Lep(i, l, r) for (int i = (l), i##_end = (r); i < i##_end; ++ i)

struct matrix {
	int _[K][K];
	inline int * operator [] (int x) & { return _[x]; }
};

inline void zero (matrix & a) { Lep (i, 0, K) Lep (j, 0, K) a[i][j] = 0; }
inline void one (matrix & a) { Lep (i, 0, K) Lep (j, 0, K) a[i][j] = i == j; }
inline void random (matrix & a) { Lep (i, 0, K) Lep (j, 0, K) a[i][j] = rnd (seed); }

inline bool g_inv (matrix a, matrix & b) {
	one (b); Lep (i, 0, K) {
		int p = -1; Lep (j, i, K) if (a[j][i]) { p = j; break ; }
		if (! ~ p) return false;
		if (p != i) swap (a._[i], a._[p]), swap (b._[i], b._[p]);

		int inv = qpow (a[i][i], mod - 2);
		Lep (j, 0, K) if (j != i) {
			int buf = mul (inv, a[j][i]);
			Lep (k, 0, K) sub (a[j][k], mul (a[i][k], buf));
			Lep (k, 0, K) sub (b[j][k], mul (b[i][k], buf));
		}
		Lep (k, 0, K) a[i][k] = mul (a[i][k], inv);
		Lep (k, 0, K) b[i][k] = mul (b[i][k], inv);
	}
	return true;
}

inline matrix operator * (matrix a, matrix b) {
	matrix c; zero (c);
	Lep (i, 0, K) Lep (j, 0, K) Lep (k, 0, K) pls (c[i][j], mul (a[i][k], b[k][j]));
	return c;
}
inline bool operator == (matrix a, matrix b) {
	Lep (i, 0, K) Lep (j, 0, K) if (a[i][j] != b[i][j]) return false;
	return true;
}

inline void print (matrix a) {
	Lep (i, 0, K) Lep (j, 0, K) debug ("%d%c", a[i][j], " \n"[j == K - 1]);
}

// }}}

const int N = 5e5 + 5;

int n, m;
char str[N];
matrix mt[3], iv[3];

// {{{ segment tree

#define lc ((x) << 1)
#define rc ((x) << 1 | 1)
#define mid ((l + r) >> 1)

short tag[N << 2];
matrix val[N << 2][3], _val;

inline void pushup (int x) {
	lep (o, 0, 2) val[x][o] = val[lc][o] * val[rc][o];
}
inline void shift (int x, int y) {
	tag[x] = (tag[x] + y) % 3;
	if (y == 1) _val = val[x][2], val[x][2] = val[x][0], val[x][0] = val[x][1], val[x][1] = _val;
	if (y == 2) _val = val[x][2], val[x][2] = val[x][1], val[x][1] = val[x][0], val[x][0] = _val;
}
inline void pushdown (int x) {
	if (tag[x]) {
		shift (lc, tag[x]);
		shift (rc, tag[x]);
		tag[x] = 0;
	}
}

void build (int x, int l, int r) {
	if (l == r) {
		int c = str[l] - '0';
		lep (o, 0, 2) val[x][o] = (l & 1) ? mt[(c + o) % 3] : iv[(c + o) % 3];
	} else {
		build (lc, l, mid), build (rc, mid + 1, r);
		pushup (x);
	}
}

void shift (int x, int l, int r, int L, int R) {
	if (L <= l && r <= R) return shift (x, 1), void ();
	pushdown (x);
	if (L <= mid) shift (lc, l, mid, L, R);
	if (R > mid) shift (rc, mid + 1, r, L, R);
	pushup (x);
}
matrix query (int x, int l, int r, int L, int R) {
	if (L == l && r == R) return val[x][0];
	pushdown (x);
	if (R <= mid) return query (lc, l, mid, L, R);
	if (L > mid) return query (rc, mid + 1, r, L, R);
	return query (lc, l, mid, L, mid) * query (rc, mid + 1, r, mid + 1, R);
}

#undef lc
#undef rc
#undef mid

// }}}

signed main () {
	IN (n), IN (m), scanf ("%s", str + 1);
	lep (o, 0, 2) for ( random (mt[o]); ! g_inv (mt[o], iv[o]); random (mt[o]) );
	build (1, 1, n);

	matrix i; one (i);
	for (int opt, l, r; m; -- m) {
		if (IN (opt), IN (l), IN (r), opt == 1) {
			shift (1, 1, n, l, r);
		} else {
			matrix q = query (1, 1, n, l, r);
			puts (q == i ? "Yes" : "No");
		}
	}
	return 0;
}