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

template <class T> int sz(T&& a) { return int(size(forward<T>(a))); }

template <class T> using vc = vector<T>;
template <class T> using vvc = vc<vc<T>>;

using ll = int64_t;
using uint = uint32_t;
using ull = uint64_t;

template <class T> T pow(T a, ll b) {
	assert(b >= 0);
	T r = 1; while (b) { if (b & 1) r *= a; b >>= 1, a *= a; } return r;
}

template <uint mod> struct mint {
	static constexpr uint m = mod;

	uint v;
	mint() : v(0) {}
	mint(ll a) { s(uint(a % m + m)); }
	mint& s(uint a) { v = a < m ? a : a - m; return *this; }
	mint operator- () const {
		mint res;
		res.v = v ? m-v : 0;
		return res;
	}
	friend mint inv(const mint& n) { return pow(n, m-2); }

	friend bool operator == (const mint& a, const mint& b) { return a.v == b.v; }
	friend bool operator != (const mint& a, const mint& b) { return a.v != b.v; }

	mint& operator += (const mint& o) { return s(v + o.v); }
	mint& operator -= (const mint& o) { return s(v + m - o.v); }
	mint& operator *= (const mint& o) { v = uint(ull(v) * o.v % m); return *this; }
	mint& operator /= (const mint& o) { return *this *= inv(o); }

	friend mint operator + (const mint& a, const mint& b) { return mint(a) += b; }
	friend mint operator - (const mint& a, const mint& b) { return mint(a) -= b; }
	friend mint operator * (const mint& a, const mint& b) { return mint(a) *= b; }
	friend mint operator / (const mint& a, const mint& b) { return mint(a) /= b; }
};

template <class N> struct seglazy {
#define fa forward<A>(args)...
	vc<N> x;
	int n, log, s;
	seglazy() {}
	template <class T> seglazy(const vc<T>& a) {
		n = int(a.size());
		log = 0;
		while ((1 << log) < n) log++;
		s = 1 << log;
		x.resize(2*s);
		for (int i = 0; i < n; i++) x[s+i] = N(a[i]);
		for (int i = s-1; i >= 1; i--) upd(i);
	}

	void upd(int i) {
		x[i] = N::merge(x[2*i], x[2*i+1]);
	}
	void push(int i) {
		x[i].push(x[2*i], x[2*i+1]);
	}

	template <bool U = true, class F, class... A> void apply(int l, int r, F f, A&&... args) {
		assert(0 <= l && l <= r && r <= n);
		if (l == r) return;
		l += s, r += s;
		for (int i = log; i >= 1; i--) {
			if (((l >> i) << i) != l) push(l >> i);
			if (((r >> i) << i) != r) push((r-1) >> i);
		}

		static int buf[2][30];
		int cnt[2]{};
		for (int a = l, b = r; a < b; a /= 2, b /= 2) {
			if (a & 1) buf[0][cnt[0]++] = a++;
			if (b & 1) buf[1][cnt[1]++] = --b;
		}
		for (int z = 0; z < cnt[0]; z++) apply(buf[0][z], f, fa);
		for (int z = cnt[1]-1; z >= 0; z--) apply(buf[1][z], f, fa);
		if constexpr(U) {
			for (int i = 1; i <= log; i++) {
				if (((l >> i) << i) != l) upd(l >> i);
				if (((r >> i) << i) != r) upd((r-1) >> i);
			}
		}
	}

	template <class F, class... A> void apply(int i, F f, A&&... args) {
		if ((x[i].*f)(fa) || i >= s) return;
		push(i);
		apply(2*i, f, fa);
		apply(2*i+1, f, fa);
		upd(i);
	}
};

const uint MOD = 998244353;
using num = mint<MOD>;

using mat = array<array<num, 2>, 2>;

mt19937 mt(114514);
int rand_int(int a, int b) {
	return uniform_int_distribution<int>(a, b)(mt);
}

mat mult(const mat& a, const mat& b) {
	mat c{};
	for (int i = 0; i < 2; i++) {
		for (int k = 0; k < 2; k++) {
			num v = a[i][k];
			for (int j = 0; j < 2; j++) {
				c[i][j] += v * b[k][j];
			}
		}
	}
	return c;
}

pair<mat, mat> gen_mat() {
	while (true) {
		mat res;
		for (int i = 0; i < 2; i++) {
			for (int j = 0; j < 2; j++) {
				res[i][j] = num(rand_int(0, MOD-1));
			}
		}
		num det = res[0][0] * res[1][1] - res[0][1] * res[1][0];
		if (det.v != 0) {
			num idet = inv(det);
			mat ires;
			ires[0][0] = res[1][1] * idet;
			ires[1][1] = res[0][0] * idet;
			ires[0][1] = (0 - res[0][1]) * idet;
			ires[1][0] = (0 - res[1][0]) * idet;
			return {res, ires};
		}
	}
}

array<mat, 3> trans;
array<mat, 3> itrans;
void precomp() {
	for (int x = 0; x < 3; x++) {
		auto [m, im] = gen_mat();
		trans[x] = m;
		itrans[x] = im;
	}
}

mat one;

using vec = array<num, 2>;

ostream& operator << (ostream& os, const mat& a) {
	for (int i = 0; i < 2; i++) {
		for (int j = 0; j < 2; j++) {
			cerr << a[i][j].v << " \n"[j==1];
		}
	}
	return os;
}

struct data_t {
	array<mat, 3> prod;
	int lazy = 0;
	data_t() : prod({one, one, one}) {}
	data_t(pair<int, bool> p) {
		if (!p.second) {
			prod = trans;
		} else {
			prod = itrans;
		}
		assert(0 <= p.first && p.first < 3);
		rotate(prod.begin(), prod.begin() + p.first, prod.end());
	}

	bool shift(int a) {
		if (a) {
			rotate(prod.begin(), prod.begin() + a, prod.end());
			lazy = (lazy + a) % 3;
		}
		return true;
	}

	bool mult_vec(vec& v) const {
		const auto& m = prod[0];
		v = {v[0] * m[0][0] + v[1] * m[1][0], v[0] * m[0][1] + v[1] * m[1][1]};
		return true;
	}

	void push(data_t& l, data_t& r) {
		if (lazy != 0) {
			l.shift(lazy);
			r.shift(lazy);
			lazy = 0;
		}
	}

	static data_t merge(const data_t& l, const data_t& r) {
		data_t res;
		for (int z = 0; z < 3; z++) {
			res.prod[z] = mult(l.prod[z], r.prod[z]);
		}
		return res;
	}
};

struct GC {
	char buf[1<<16];
	size_t s = 0, e = 0;
	char operator()() {
		if (s >= e) {
			buf[0] = 0;
			s = 0;
			e = fread(buf, 1, sizeof(buf), stdin);
		}
		return buf[s++];
	}
} gc;

int scan_int() {
	char c;
	while ((c = gc()) < 40);
	if (c == '-') return -scan_int();
	int a = c - '0';
	while (isdigit(c = gc())) a = a * 10 + c - '0';
	return a;
}

int main() {
	ios_base::sync_with_stdio(false), cin.tie(nullptr);

	precomp();

	int N = scan_int();
	int Q = scan_int();
	vector<int> A(N);
	{
		string s;
		char c;
		while (!isdigit(c = gc()));
		s += c;
		while (isdigit(c = gc())) s += c;
		for (int i = 0; i < N; i++) {
			A[i] = int(s[i] - '0');
			assert(0 <= A[i] && A[i] < 3);
		}
	}

	one[0][0] = one[1][1] = 1;

	vector<pair<int, bool>> init(N);
	for (int i = 0; i < N; i++) {
		init[i] = {A[i], bool(i % 2)};
	}
	seglazy<data_t> st(init);

	while (Q--) {
		int op = scan_int();
		int l = scan_int() - 1;
		int r = scan_int();
		if (op == 1) {
			st.apply<true>(l, r, &data_t::shift, +1);
		} else if (op == 2) {
			bool works = true;
			for (vec f : {vec{1, 0}, vec{0, 1}}) {
				vec g = f;
				st.apply<false>(l, r, &data_t::mult_vec, g);
				if (g != f) {
					works = false;
					break;
				}
			}
			cout << (works ? "Yes" : "No") << '\n';
		} else assert(false);
	}
}