#include<bits/stdc++.h>

using namespace std;

#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define pf push_front
#define LC k<<1
#define RC k<<1|1
#define IO cin.sync_with_stdio(false); cin.tie(0); cout.tie(0);
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((int)(x).size())
#define rep(i, a, n) for (int i = a; i < n; i++)
#define repn(i, a, n) for (int i = a; i <= n; i++)
#define per(i, a, n) for (int i = (n) - 1; i >= a; i--)
#define pern(i, a, n) for (int i = n; i >= a; i--)

typedef long long LL;
typedef long double LD;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef pair<int, LL> PIL;
typedef pair<LL, int> PLI;
typedef pair<double, double> PDD;
typedef pair<ull, ull> PUU;
typedef pair<LL, LL> PLL;

const int N = 510000;
const int M = 2100000;
const int mod = 1e9+7;
const int inf = (int)1e9;
const LL INF = 1e18;
const double eps = 1e-9;

mt19937_64 Rand((unsigned long long)new char);
#define rand Rand

const int MAXN = 3;
struct Matrix {
	int n, m;
	LL a[MAXN][MAXN];
	friend bool operator == (const Matrix &a, const Matrix &b) {
		if (a.n != b.n || a.m != b.m) return 0;
		rep(i, 0, a.n) rep(j, 0, a.m) if (a.a[i][j] != b.a[i][j]) return 0;
		return 1;
	}
	void clear() {
		n = m = 0;
		memset(a, 0, sizeof(a));
	}
	void unit() {
		memset(a, 0, sizeof(a));
		rep(i, 0, n) a[i][i] = 1;
	}
	void rand_init() {
		rep(i, 0, n) rep(j, 0, n) a[i][j] = rand() % mod;
	}
	LL pow_mod(LL a, LL e) {
		LL res = 1;
		for (; e; a = a * a % mod, e >>= 1) if (e & 1) res = res * a % mod;
		return res;
	}
	Matrix split(int x1, int y1, int x2, int y2) {
		Matrix res;
		res.clear(); res.n = x2 - x1 + 1, res.m = y2 - y1 + 1;
		repn(i, x1, x2) repn(j, y1, y2) res.a[i - x1][j - y1] = a[i][j];
		return res;
	}
	Matrix operator * (const Matrix &b) const {
		Matrix tmp;
		tmp.clear();
		tmp.n = n, tmp.m = b.m;
		rep(i, 0, n) rep(j, 0, b.m) rep(k, 0, m) 
		    tmp.a[i][j] = (tmp.a[i][j] + a[i][k] * b.a[k][j]) % mod;
		return tmp;
    }
	LL det_mod() {
		assert(n == m);
		Matrix backup = (*this);
		rep(i, 0, n) rep(j, 0, m) a[i][j] = (a[i][j] + mod) % mod;
		LL res = 1;
		rep(i, 0, n) {
			if (!a[i][i]) {
				rep(j, i, n) {
					if (a[j][i]) {
						rep(k, i, n) swap(a[j][k], a[i][k]);
						break;
					}
				}
				res = mod - res;
			}
			LL inv = pow_mod(a[i][i], mod - 2);
			rep(j, 0, n) {
				if (j != i) {
					LL coef = inv * a[j][i] % mod;
					rep(k, i, n) a[j][k] = (a[j][k] - coef * a[i][k] % mod + mod) % mod;
				}
			}
		}
		rep(i, 0, n) res = res * a[i][i] % mod;
		(*this) = backup;
		return res;
	}
	Matrix inverse() {
		assert(n == m);
		Matrix res, backup = (*this);
		res.n = res.m = n;
		res.unit();
		rep(i, 0, n) {
			int pos = -1;
			rep(j, i, n) {
				if (a[j][i]) {
					pos = j;
					break;
				}
			}
			if (pos == -1) {
				res.n = -1;
				return res;
			}
			rep(j, 0, n) swap(a[pos][j], a[i][j]), swap(res.a[pos][j], res.a[i][j]);
			LL coef = pow_mod(a[i][i], mod - 2);
			rep(j, 0, n) a[i][j] = a[i][j] * coef % mod, res.a[i][j] = res.a[i][j] * coef % mod;
			rep(j, 0, n) if (i != j) {
				LL coef = a[j][i];
				rep(k, 0, n) {
					a[j][k] = (a[j][k] - a[i][k] * coef % mod + mod) % mod;
					res.a[j][k] = (res.a[j][k] - res.a[i][k] * coef % mod + mod) % mod;
				}
			}
		}
		(*this) = backup;
		return res;
	}
}a[3], b[3], tr[M][3], I, tmp[3];
int lz[M];
Matrix pow_mod(Matrix a, LL e) {	
	Matrix res = a;
	res.unit();
	for (; e; a = a * a, e >>= 1) if (e & 1) res = res * a;
	return res;
}
int n, m, arr[N];
string s;
void update(int k) {
	rep(i, 0, 3) tr[k][i] = tr[LC][i] * tr[RC][i];
}
void pushdown(int k) {
	if (lz[k]) {
		rep(i, 0, 3) tmp[i] = tr[LC][(i + lz[k]) % 3];
		rep(i, 0, 3) tr[LC][i] = tmp[i];
		rep(i, 0, 3) tmp[i] = tr[RC][(i + lz[k]) % 3];
		rep(i, 0, 3) tr[RC][i] = tmp[i];
		lz[LC] = (lz[LC] + lz[k]) % 3;
		lz[RC] = (lz[RC] + lz[k]) % 3;
		lz[k] = 0;
	}
}
void build(int k, int l, int r) {
	if (l == r) {
		if (l & 1) {
			rep(i, 0, 3) tr[k][i] = b[(arr[l] + i) % 3];
		}
		else {
			rep(i, 0, 3) tr[k][i] = a[(arr[l] + i) % 3];
		}
		return;
	}
	int mid = (l + r) / 2;
	build(LC, l, mid);
	build(RC, mid + 1, r);
	update(k);
}
void change(int k, int l, int r, int a, int b) {
	if (l == a && r == b) {
		lz[k] = (lz[k] + 1) % 3;
		rep(i, 0, 3) tmp[i] = tr[k][(i + 1) % 3];
		rep(i, 0, 3) tr[k][i] = tmp[i];
		return;
	}
	int mid = (l + r) / 2;
	pushdown(k);
	if (b <= mid) change(LC, l, mid, a, b);
	else if (a > mid) change(RC, mid + 1, r, a, b);
	else change(LC, l, mid, a, mid), change(RC, mid + 1, r, mid + 1, b);
	update(k);
}
Matrix ask(int k, int l, int r, int a, int b) {
	if (l == a && r == b) return tr[k][0];
	int mid = (l + r) / 2;
	pushdown(k);
	Matrix res;
	if (b <= mid) res = ask(LC, l, mid, a, b);
	else if (a > mid) res = ask(RC, mid + 1, r, a, b);
	else res = ask(LC, l, mid, a, mid) * ask(RC, mid + 1, r, mid + 1, b);
	update(k);
	return res;
}
int main() {
	IO;
	I.n = I.m = MAXN;
	I.unit();
	rep(i, 0, 3) {
		a[i].n = a[i].m = MAXN;
		while (1) {
			a[i].rand_init();
			b[i] = a[i].inverse();
			if (b[i].n != -1) break;
		}
		assert(a[i] * b[i] == I);
		assert(b[i] * a[i] == I);
	}
	cin >> n >> m;
	cin >> s;
	repn(i, 1, n) arr[i] = s[i - 1] - '0';
	build(1, 1, n);
	while (m--) {
		int op, l, r;
		cin >> op >> l >> r;
		if (op == 1) change(1, 1, n, l, r);
		else {
			Matrix res = ask(1, 1, n, l, r);
			if (res == I) cout << "Yes\n";
			else cout << "No\n";
		}
	}
	return 0;
}