#include <bits/stdc++.h>
using namespace std;

typedef long long ll;

const int N = 5e5 + 5;
const int mod = 998244353;

ll A[3][2][2], B[3][2][2];

inline void init() {
	A[0][0][0] = 552536130, A[0][0][1] = 156609953;
	A[0][1][0] = 852702545, A[0][1][1] = 11466168;
	B[0][0][0] = 37036524, B[0][0][1] = 155595907;
	B[0][1][0] = 733350338, B[0][1][1] = 336894995;
	A[1][0][0] = 263294128, A[1][0][1] = 493189256;
	A[1][1][0] = 556963625, A[1][1][1] = 232185797;
	B[1][0][0] = 985084565, B[1][0][1] = 364362434;
	B[1][1][0] = 601294606, B[1][1][1] = 210730920;
	A[2][0][0] = 184382960, A[2][0][1] = 33159178;
	A[2][1][0] = 41061133, A[2][1][1] = 338270988;
	B[2][0][0] = 287895845, B[2][0][1] = 444044418;
	B[2][1][0] = 486430156, B[2][1][1] = 815560590;
}

inline void addmod(ll &x) {
	(x >= mod) && (x -= mod);
}

struct mat {
	ll p[2][2];

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

	inline mat operator*(const mat &rhs) const {
		mat res;
		for (int i = 0; i < 2; ++i) {
			for (int j = 0; j < 2; ++j) {
				for (int k = 0; k < 2; ++k) {
					addmod(res.p[i][j] += p[i][k] * rhs.p[k][j] % mod);
				}
			}
		}
		return res;
	}
} P[3], Q[3];

mat tree[N << 2][3];

int n, q, a[N], tag[N << 2];

string S;	

inline void move(int i, int k) {
	if (k == 1) {
		swap(tree[i][0], tree[i][1]);
		swap(tree[i][1], tree[i][2]);
	} else if (k == 2) {
		swap(tree[i][1], tree[i][2]);
		swap(tree[i][0], tree[i][1]);
	}
}

inline void pushup(int i) {
	for (int j = 0; j < 3; ++j) {
		tree[i][j] = tree[i << 1][j] * tree[i << 1 | 1][j];
	}
}

inline void pushdown(int i) {
	if (!tag[i]) {
		return;
	}
	tag[i << 1] = (tag[i << 1] + tag[i]) % 3;
	tag[i << 1 | 1] = (tag[i << 1 | 1] + tag[i]) % 3;
	move(i << 1, tag[i]);
	move(i << 1 | 1, tag[i]);
	tag[i] = 0;
}

inline void build(int i, int l, int r) {
	if (l == r) {
		if (l & 1) {
			for (int j = 0; j < 3; ++j) {
				tree[i][j] = P[j];
			}
		} else {
			for (int j = 0; j < 3; ++j) {
				tree[i][j] = Q[j];
			}
		}
		move(i, a[l]);
		return;
	}
	int mid = (l + r) >> 1;
	build(i << 1, l, mid);
	build(i << 1 | 1, mid + 1, r);
	pushup(i);
}

inline void update(int i, int l, int r, int ql, int qr) {
	if (ql <= l && r <= qr) {
		move(i, 1);
		tag[i] = (tag[i] + 1) % 3;
		return;
	}
	pushdown(i);
	int mid = (l + r) >> 1;
	if (ql <= mid) {
		update(i << 1, l, mid, ql, qr);
	}
	if (qr > mid) {
		update(i << 1 | 1, mid + 1, r, ql, qr);
	}
	pushup(i);
}

inline mat query(int i, int l, int r, int ql, int qr) {
	if (ql <= l && r <= qr) {
		return tree[i][0];
	}
	pushdown(i);
	int mid = (l + r) >> 1;
	if (qr <= mid) {
		return query(i << 1, l, mid, ql, qr);
	}
	if (ql > mid) {
		return query(i << 1 | 1, mid + 1, r, ql, qr);
	}
	return query(i << 1, l, mid, ql, qr) * query(i << 1 | 1, mid + 1, r, ql, qr);
}

int main() {
	#ifdef LOCAL
		assert(freopen("xiao.in", "r", stdin));
		assert(freopen("xiao.out", "w", stdout));
	#endif
	ios::sync_with_stdio(false); cin.tie(nullptr); cout.tie(nullptr);
	init();
	for (int k = 0; k < 3; ++k) {
		for (int i = 0; i < 2; ++i) {
			for (int j = 0; j < 2; ++j) {
				P[k].p[i][j] = A[k][i][j];
				Q[k].p[i][j] = B[k][i][j];
			}
		}
	}
	cin >> n >> q >> S;
	for (int i = 1; i <= n; ++i) {
		a[i] = S[i - 1] - '0';
	}
	build(1, 1, n);
	while (q--) {
		int op, l, r;
		cin >> op >> l >> r;
		if (op == 1) {
			update(1, 1, n, l, r);
		} else {
			mat res = query(1, 1, n, l, r);
			bool flg = true;
			for (int i = 0; i < 2; ++i) {
				for (int j = 0; j < 2; ++j) {
					flg &= (res.p[i][j] == (i == j));
				}
			}
			if (flg) {
				cout << "Yes\n";
			} else {
				cout << "No\n";
			}
		}
	}
	return 0;
}