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

using ll = long long;
#define int ll
#define all(v) (v).begin(), (v).end()
#define pb push_back

void dbg_out() { cerr << endl; }
template <typename H, typename... T>
void dbg_out(H h, T... t) { cerr << ' ' << h; dbg_out(t...); }
#define dbg(...) { cerr << #__VA_ARGS__ << ':'; dbg_out(__VA_ARGS__); }

template <const int MOD>
struct mint {
	int x;
	mint(): x(0) {}
	mint(int _x): x(_x%MOD<0?_x%MOD+MOD:_x%MOD) {}
	void operator+=(mint rhs) { x+=rhs.x; if(x>=MOD) x-=MOD; }
	void operator-=(mint rhs) { x-=rhs.x; if(x<0)x+=MOD; }
	void operator*=(mint rhs) { x*=rhs.x; x%=MOD; }
	void operator/=(mint rhs) { *this *= rhs.inv(); }
	mint operator+(mint rhs) { mint res=*this; res+=rhs; return res; }
	mint operator-(mint rhs) { mint res=*this; res-=rhs; return res; }
	mint operator*(mint rhs) { mint res=*this; res*=rhs; return res; }
	mint operator/(mint rhs) { mint res=*this; res/=rhs; return res; }
	bool operator==(mint rhs) { return x == rhs.x; }
	mint inv() { assert(x != 0); return this->pow(MOD-2); }
	mint pow(int e) {
		mint res(1);
		for(mint p=*this;e>0;e/=2,p*=p) if(e%2)
			res*=p;
		return res;
	}
};

using Z = mint<998244353>;
using row = array<Z, 2>;
using matrix = array<row, 2>;

array<matrix, 3> mat = {
	matrix{
		row{1, 92},
		row{3, 94}
	},
	matrix{
		row{3425, 346},
		row{4572, 123}
	},
	matrix{
		row{13534, 101346},
		row{11238, 138323}
	}
};
array<matrix, 3> mat_inv;

matrix I = {
	row{1, 0},
	row{0, 1}
};

bool is_identity(matrix m) {
	for(int i=0;i<2;i++) for(int j=0;j<2;j++) {
		if(m[i][j].x != (i == j)) return false;
	}
	return true;
}

matrix operator*(matrix lhs, matrix rhs) {
	matrix res;
	for(int i=0;i<2;i++) for(int k=0;k<2;k++) for(int j=0;j<2;j++)
		res[i][j] += lhs[i][k] * rhs[k][j];
	return res;
}

namespace seg {
	constexpr int N = 500'000;
	int state[2*N-1], lz[2*N-1];
	array<matrix, 3> seg[2*N-1];
	
	void pull(int nd, int l, int r) {
		assert(l < r);
		int m = (l + r) / 2;
		int x = nd + 1, y = nd + 2*(m - l + 1);

		for(int k=0;k<3;k++) {
			int snd = (state[nd] + k) % 3;
			int sx = (state[x] + k) % 3;
			int sy = (state[y] + k) % 3;
			seg[nd][snd] = seg[x][sx] * seg[y][sy];
		}
	}

	void push(int nd, int l, int r) {
		if(lz[nd] % 3 != 0) {
			state[nd] = (state[nd] + lz[nd]) % 3;
			if(l != r) {
				int m = (l + r) / 2;
				int x = nd + 1, y = nd + 2*(m - l + 1);
				lz[x] += lz[nd];
				lz[y] += lz[nd];
			}
			lz[nd] = 0;
		}
	}

	void update(int nd, int l, int r, int ql, int qr) {
		push(nd, l, r);
		if(qr < l || r < ql) return;
		if(ql <= l && r <= qr) {
			lz[nd]++;
			push(nd, l, r);
			return;
		}
		int m = (l + r) / 2;
		int x = nd + 1, y = nd + 2*(m - l + 1);
		update(x, l, m, ql, qr);
		update(y, m+1, r, ql, qr);
		pull(nd, l, r);
	}

	matrix query(int nd, int l, int r, int ql, int qr) {
		push(nd, l, r);
		if(qr < l || r < ql) return I;
		if(ql <= l && r <= qr) {
			return seg[nd][state[nd]];
		}
		int m = (l + r) / 2;
		int x = nd + 1, y = nd + 2*(m - l + 1);
		return query(x, l, m, ql, qr) * query(y, m+1, r, ql, qr);
	}

	void build(int nd, int l, int r, string &s) {
		if(l == r) {
			state[nd] = s[l] - '0';
			assert(0 <= state[nd] && state[nd] < 3);
			if(l%2 == 0) 
				seg[nd] = mat;
			else
				seg[nd] = mat_inv;
			return;
		}
		int m = (l + r) / 2;
		int x = nd + 1, y = nd + 2*(m - l + 1);
		build(x, l, m, s);
		build(y, m+1, r, s);
		pull(nd, l, r);
	}
}

void init() {
	for(int i=0;i<3;i++) {
		auto &a = mat[i];
		auto &b = mat_inv[i];
		auto f = (a[0][0] * a[1][1] - a[1][0] * a[0][1]).inv();
		b[0][0] = a[1][1] * f;
		b[1][1] = a[0][0] * f;
		b[0][1] =  (Z(0)-a[0][1]) * f;
		b[1][0] =  (Z(0)-a[1][0]) * f;

		assert(is_identity(a * b));
	}
}

void solve() {
	int n, q;
	cin >> n >> q;
	string s; 
	cin >> s;
	seg::build(0, 0, n-1, s);
	while(q--) {
		int ops, l, r; cin >> ops >> l >> r;
		--l; --r;
		if(ops == 1) {
			seg::update(0, 0, n-1, l, r);
		} else {
			if(is_identity(seg::query(0, 0, n-1, l, r))) {
				cout << "Yes" << '\n';
			} else {
				cout << "No" << '\n';
			}
		}
	}
}

signed main(){
	ios::sync_with_stdio(false);
	cin.tie(nullptr);

	init();

	solve();
}