#include <bits/stdc++.h>
using namespace std;
bool stB;
namespace SOL {

void debug(const char *msg, ...) {
#ifdef CLESIP
    va_list arg;
    static char pbString[512];
    va_start(arg,msg);
    vsprintf(pbString,msg,arg);
    cerr << "[DEBUG] " << pbString << "\n";
    va_end(arg);
#endif    
}

#define PASSED debug("PASSED (%s) LINE #%s", __FUNCTION__, __LINE__)

using i64 = long long;
using i128 = __int128_t;
template <typename T, typename L> void chkmax(T &x, L y) { if (x < y) x = y; }
template <typename T, typename L> void chkmin(T &x, L y) { if (x > y) x = y; }

const int N = 5e5 + 10;
const int K = 3;
const i64 P = 998244353;

i64 qpow(i64 a, i64 b) {
	i64 ret = 1;
	for (; b; b >>= 1) {
		if (b & 1)
			ret = ret * a % P;
		a = a * a % P;
	}
	return ret;
}

void add(i64 &x, i64 y) {
	x += y;
	if (x >= P)
		x -= P;
}

struct Matrix {
	i64 mat[2][2];

	Matrix() {
		memset(mat, 0, sizeof(mat));
	}

	operator bool () const {
		for (int i = 0; i < 2; i ++)
			if (mat[i][i] != 1)
				return false;
		for (int i = 0; i < 2; i ++)
			for (int j = 0; j < 2; j ++) if (i != j && mat[i][j] != 0)
				return false;
		return true;
	}
} base[K][2];

Matrix operator * (const Matrix &A, const Matrix &B) {
	Matrix C;

	for (int i = 0; i < 2; i ++)
		for (int j = 0; j < 2; j ++) {
			i64 c = 0;
			for (int k = 0; k < 2; k ++)
				add(c, A.mat[i][k] * B.mat[k][j] % P);
			C.mat[i][j] = c;
		}

	return C;
}

pair<Matrix, bool> matrix_inv(const Matrix &mat) {
	static i64 a[2][4];
	Matrix ret;
	int n = 2;
	memset(a, 0, sizeof(a));
	for (int i = 0; i < n; i ++)
		for (int j = 0; j < n; j ++)
			a[i][j] = mat.mat[i][j];
	for (int i = 0; i < n; i ++)
		a[i][i + n] = 1;
	for (int j = 0; j < n; j ++) {
		int col = -1;
		for (int i = j; i < n; i ++) if (a[i][j] != 0) {
			col = i;
			break;
		}
		if (col == -1)
			return { ret, false };
		swap(a[j], a[col]);
		i64 inv = qpow(a[j][j], P - 2);
		for (int i = 0; i < n; i ++) if (i != j) {
			i64 scale = a[i][j] * inv % P;
			for (int k = 0; k < 2 * n; k ++) {
				add(a[i][k], P - a[j][k] * scale % P);
			}
		}
	}
	for (int i = 0; i < n; i ++) {
		i64 inv = qpow(a[i][i], P - 2);
		for (int j = n; j < 2 * n; j ++)
			ret.mat[i][j - n] = a[i][j] * inv % P;
	}
	return { ret, true };
}

mt19937 rng(random_device{}());
mt19937_64 rng_64(random_device{}());

int rand_int(int l, int r) {
	return uniform_int_distribution<>(l, r)(rng);
}

char rand_char() {
	return 'a' + rand_int(0, 25);
}

const vector<char> DEFAULT_CHARSET = { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z' };

string rand_string(int len, vector<char> charset = DEFAULT_CHARSET) {
	string s;
	for (int i = 0; i < len; i ++)
		s = s + charset[rand_int(0, charset.size() - 1)];
	return s;
}

i64 rand_i64(i64 l, i64 r) {
	return uniform_int_distribution<i64>(l, r)(rng_64);
}

Matrix generate_matrix() {
	Matrix ret;
	for (int i = 0; i < 2; i ++)
		for (int j = 0; j < 2; j ++)
			ret.mat[i][j] = rand_int(0, P - 2);
	return ret;
}

namespace LazySegmentTree {
	const int SEG_SIZE = N * 4;
	template<typename Node, typename Tag>
	struct LazyTagSegTree {
		#define lc (x * 2)
		#define rc (x * 2 + 1)
		#define mid ((l + r) >> 1)

		Node dat[SEG_SIZE];
		Tag tag[SEG_SIZE];

		void pull(int x) {
			dat[x] = dat[lc] + dat[rc];
		}

		void apply(int x, const Tag &t, int sze) {
			dat[x].apply(t, sze);
			tag[x].apply(t);
		}

		void push(int x, int l, int r) {
			if (tag[x]) {
				apply(lc, tag[x], mid - l + 1);
				apply(rc, tag[x], r - mid);
				tag[x].clear();
			}
		}

		void build(int x, int l, int r) {
			tag[x].clear();
			if (l == r) {
				dat[x].init(l);
				return;
			}
			build(lc, l, mid);
			build(rc, mid + 1, r);
			pull(x);
		}

		Node query(int x, int l, int r, int ql, int qr) {
			if (ql <= l && r <= qr) 
				return dat[x];
			push(x, l, r);
			if (ql <= mid && mid < qr)
				return query(lc, l, mid, ql, qr) + query(rc, mid + 1, r, ql, qr);
			else if (ql <= mid)
				return query(lc, l, mid, ql, qr);
			else
				return query(rc, mid + 1, r, ql, qr);
		}

		void modify(int x, int l, int r, int ql, int qr, const Tag &t) {
			if (ql > qr)
				return;
			if (ql <= l && r <= qr) 
				return apply(x, t, r - l + 1);
			push(x, l, r);
			if (ql <= mid)
				modify(lc, l, mid, ql, qr, t);
			if (mid < qr)
				modify(rc, mid + 1, r, ql, qr, t);
			pull(x);
		}

		void change(int x, int l, int r, int pos, const Node &k) {
			if (l == r)
				return dat[x] = k, void();
			push(x, l, r);
			if (pos <= mid)
				change(lc, l, mid, pos, k);
			else
				change(rc, mid + 1, r, pos, k);
			pull(x);
		} 

		#undef lc
		#undef rc
		#undef mid
	};
}

void init() {
	for (int i = 0; i < K; i ++) {
		while (!matrix_inv(base[i][0] = generate_matrix()).second);
		base[i][1] = matrix_inv(base[i][0]).first;
	}
}

int n, q;
char s[N];

struct Tag {
	int offset;

	operator bool () {
		return offset;
	}

	void clear() {
		offset = 0;
	}

	void apply(const Tag &o) {
		offset = (offset + o.offset) % 3;
	}
};

struct Node {
	Matrix mat[3];

	void init(int p) {
		int ch = s[p] - '0';

		for (int i = 0; i < 3; i ++)
			mat[i] = base[(ch + i) % 3][p % 2];
	}

	void apply(const Tag &o, int _) {
		static Matrix res[3];
		for (int i = 0; i < 3; i ++)
			res[(i - o.offset + 3) % 3] = mat[i];
		for (int i = 0; i < 3; i ++)
			mat[i] = res[i];
	}
};

Node operator + (const Node &lhs, const Node &rhs) {
	Node ret;

	for (int i = 0; i < 3; i ++)
		ret.mat[i] = lhs.mat[i] * rhs.mat[i];

	return ret;
}

LazySegmentTree::LazyTagSegTree<Node, Tag> segt;

void solve() {
	init();
	cin >> n >> q;
	cin >> (s + 1);
	segt.build(1, 1, n);
	while (q --) {
		int op, l, r; cin >> op >> l >> r;
		if (op == 1) {
			segt.modify(1, 1, n, l, r, { 1 });
		} else {
			if (segt.query(1, 1, n, l, r).mat[0])
				cout << "Yes\n";
			else
				cout << "No\n";
		}
	}
}

}
bool edB;
signed main() {
	// cerr << "Memory: " << (&stB - &edB) / 1024.0 / 1024.0 << "MB\n";
	ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
	SOL::solve();
	return 0;
}

/*
8 2
01211200
2 3 6
2 1 8
*/

/*
8 5
01211012
2 4 5
2 3 6
1 6 8
2 3 6
2 1 8
*/