#include <bits/stdc++.h>

#define fir first
#define sec second
#define mkp make_pair
#define mkt make_tuple
#ifdef LOCAL
#define dbg(x) cerr << "In Line " << __LINE__ << " the " << #x << " = " << x << '\n'
#define dpi(x, y) cerr << "In Line " << __LINE__ << " the " << #x << " = " << x << " ; " << "the " << #y << " = " << y << '\n'
#define dbgf(fmt, args...) fprintf(stderr, fmt, ##args)
#else
#define dbg(x) void()
#define dpi(x, y) void()
#define dbgf(fmt, args...) void()
#endif

using namespace std;

using ll = long long;
using ull = unsigned long long;
using ui = unsigned int;
using ldb = long double;
using i128 = __int128_t;
using ui128 = __uint128_t;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using vi = vector<int>;
using vpii = vector<pii>;

namespace {
bool Mbe;
constexpr int MOD = 998244353;
template<typename T> T Norm(T a, T p = MOD) { return (a % p + p) % p; }
template<typename T> T add(T a, T b, T p = MOD) { return (a + b >= p) ? (a + b - p) : (a + b); }
template<typename T> T del(T a, T b, T p = MOD) { return (a - b < 0) ? (a - b + p) : (a - b); }
template<typename T> T mul(T a, T b, T p = MOD) { return 1ll * a * b % p; }
template<typename T> T cadd(T &a, T b, T p = MOD) { return a = add(a, b, p); }
template<typename T> T cdel(T &a, T b, T p = MOD) { return a = del(a, b, p); }
template<typename T> T cmul(T &a, T b, T p = MOD) { return a = mul(a, b, p); }
template<typename T> bool cmax(T &a, T b) { return a < b ? a = b, true : false; }
template<typename T> bool cmin(T &a, T b) { return a > b ? a = b, true : false; }
template<typename T> T DivFloor(T a, T b) { return a >= 0 ? a / b : (a - b + 1) / b; }
template<typename T> T DivCeil(T a, T b) { return a >= 0 ? (a + b - 1) / b : a / b; }

namespace FastIO {
	constexpr int LEN = 1 << 20;
	char in[LEN + 1], out[LEN + 1];
	char *pin = in, *pout = out, *ein = in, *eout = out + LEN;

	char gc() { return pin == ein && (ein = (pin = in) + fread(in, 1, LEN, stdin), ein == in) ? EOF : *pin ++; }
	void pc(char c) { pout == eout && (fwrite(out, 1, LEN, stdout), pout = out); (*pout ++) = c; return; }
	struct Flush { ~Flush() { fwrite(out, 1, pout - out, stdout); pout = out; return; } } _flush;

	template<typename T> T Read() {
		T x = 0; int f = 1; char ch = gc();
		while (ch < '0' || ch > '9') f = (ch == '-' ? (~f + 1) : f), ch = gc();
		while (ch >= '0' && ch <= '9') x = (x << 1) + (x << 3) + (ch ^ 48), ch = gc();
		return x * f;
	}
	void Read(char *s) {
		char ch = gc();
		while (ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t') ch = gc();
		while ((ch != EOF) && !(ch == ' ' || ch == '\n' || ch == '\r' || ch == '\t')) *s = ch, s ++, ch = gc();
		*s = '\0'; return;
	}
	template<typename T> void Read(T &x) { x = Read<T>(); return; }
	template<typename T, typename ...Args>
	void Read(T &x, Args &...args) { Read(x), Read(args...); return; }
	template<typename T> void Write(T x) {
		static char stk[40]; int tp = 0;
		if (x < 0) pc('-'), x = ~x + 1;
		do stk[tp++] = x % 10 + 48, x /= 10; while (x);
		while (tp --) pc(stk[tp]);
		return;
	}
	void Write(char ch) { pc(ch); return; }
	void Write(const char *s) {
		while (*s != '\0') pc(*s), s ++;
		return;
	}
	void Puts(const char *s) {
		Write(s), pc('\n'); return;
	}
	template<typename T, typename ...Args>
	void Write(T x, Args ...args) { Write(x), Write(args...); return; }
}
using FastIO::Read;
using FastIO::Write;
using FastIO::Puts;

#define getchar FastIO::gc
#define putchar FastIO::pc

int Pow(int a, int b) {
	int ans = 1;
	for (; b; b >>= 1, cmul(a, a))
		if (b & 1) cmul(ans, a);
	return ans;
}

mt19937 rnd((time(0)) ^ (ull)(new char));
struct Matrix {
	int a[2][2];
	
	Matrix() {
		for (int i : {0, 1})
			for (int j : {0, 1}) a[i][j] = i == j;
		return;
	}
	void Genshin() {
		do {
			a[0][0] = rnd() % MOD, a[0][1] = rnd() % MOD, a[1][1] = del(0, a[0][0]);
			a[1][0] = mul(del(1, mul(a[0][0], a[0][0])), Pow(a[0][1], MOD - 2));
//			cerr << a[0][0] << ' ' << a[0][1] << ' ' << a[1][0] << ' ' << a[1][1] << endl;
		} while (!(a[0][0] && a[0][1] && a[1][0] && a[1][1]));
		return;
	}
	friend Matrix operator * (Matrix x, Matrix y) {
		Matrix ans;
		for (int i : {0, 1}) for (int j : {0, 1}) ans.a[i][j] = 0;
		for (int i : {0, 1}) for (int j : {0, 1})
			for (int k : {0, 1}) cadd(ans.a[i][j], mul(x.a[i][k], y.a[k][j]));
		return ans;
	}
	friend bool operator < (const Matrix &x, const Matrix &y) {
		for (int i : {0, 1}) for (int j : {0, 1})
			if (x.a[i][j] != y.a[i][j]) return x.a[i][j] < y.a[i][j];
		return false; 
	}
	friend bool operator == (const Matrix &x, const Matrix &y) {
		for (int i : {0, 1}) for (int j : {0, 1})
			if (x.a[i][j] != y.a[i][j]) return false;
		return true;
	}
	friend ostream& operator << (ostream& os, const Matrix &x) {
		for (int i : {0, 1}) for (int j : {0, 1})
			os << x.a[i][j] << ' ';
		return os;
	}
};

template<class Info, class Tag, const int SZ>
struct Segment_Tree {
	private:
		int n, ps[SZ];
		struct Node { Info dt; Tag tg; } sgt[SZ << 2];
		vector<Info> ve; vector<int> _vec;
		vector<tuple<int, int, int>> vec;
		
		constexpr void Push_Up(int p) { sgt[p].dt = sgt[p << 1].dt + sgt[p << 1 | 1].dt; return; }
		constexpr void Push_Tag(int p, Tag tg) { sgt[p].dt = tg.Apply(sgt[p].dt), sgt[p].tg = tg * sgt[p].tg; return; }
		constexpr void Push_Down(int p) { if (sgt[p].tg) Push_Tag(p << 1, sgt[p].tg), Push_Tag(p << 1 | 1, sgt[p].tg), sgt[p].tg = Tag(); return; }
		constexpr void Build(int p, int L, int R) {
			sgt[p].tg = Tag();
			if (L == R) { ps[L] = p; sgt[p].dt = ve[L]; return; }
			int Mid = (L + R) >> 1; Build(p << 1, L, Mid);
			Build(p << 1 | 1, Mid + 1, R); Push_Up(p); return;
		}
		constexpr void Extract(int l, int r, int p, int L, int R) {
			if (l <= L && R <= r) { vec.emplace_back(p, L, R); return; }
			Push_Down(p); int Mid = (L + R) >> 1;
			if (l <= Mid) Extract(l, r, p << 1, L, Mid);
			if (Mid < r) Extract(l, r, p << 1 | 1, Mid + 1, R);
			_vec.emplace_back(p); return;
		}
	public:
		constexpr void Build(int _n) {
			ve.assign(n = _n, Info());
			Build(1, 0, n - 1); return;
		}
		template<class T> constexpr void Build(const vector<T> &a) {
			ve.resize(n = (int)a.size());
			for (int i = 0; i < n; i ++) ve[i] = a[i];
			Build(1, 0, n - 1); return;
		}	
		template<class _InputIterator, class = _RequireInputIter<_InputIterator>>
		constexpr void Build(_InputIterator __first, _InputIterator __last) {
			ve.resize(n = __last - __first);
			for (auto it = __first; it != __last; it ++) ve[it - __first] = *it;
			Build(1, 0, n - 1); return;
		}
		template<class F> constexpr void Build(int _n, F f) {
			ve.resize(n = _n);
			for (int i = 0; i < n; i ++) ve[i] = f(i);
			Build(1, 0, n - 1); return;
		}
		constexpr void Update(int l, int r, Tag k) {
			_vec.clear(), vec.clear();
			Extract(l, r, 1, 0, n - 1);
			for (auto [p, L, R] : vec) Push_Tag(p, k);
			for (auto p : _vec) Push_Up(p);
			return;
		}
		constexpr void Update(int pos, Tag k) {
			_vec.clear(); pos = ps[pos];
			while (pos) _vec.emplace_back(pos), pos >>= 1;
			for (int i = (int)_vec.size() - 1; i; i --) Push_Down(_vec[i]);
			Push_Tag(_vec.front(), k);
			for (int i = 1; i < (int)_vec.size(); i ++) Push_Up(_vec[i]);
			return;
		}
		constexpr void Change(int pos, Info k) {
			_vec.clear(); pos = ps[pos];
			while (pos) _vec.emplace_back(pos), pos >>= 1;
			for (int i = (int)_vec.size() - 1; i; i --) Push_Down(_vec[i]);
			sgt[_vec.front()].dt = k;
			for (int i = 1; i < (int)_vec.size(); i ++) Push_Up(_vec[i]);
			return;
		}
		constexpr Info Query() { return sgt[1].dt; }
		constexpr Info Query(int l, int r) {
			_vec.clear(), vec.clear();
			Extract(l, r, 1, 0, n - 1);
			Info ans = sgt[get<0>(vec.front())].dt;
			for (int i = 1; i < (int)vec.size(); i ++)
				ans = ans + sgt[get<0>(vec[i])].dt;
			return ans;
		}
		constexpr Info Query(int pos) {
			_vec.clear(); pos = ps[pos];
			while (pos) _vec.emplace_back(pos), pos >>= 1;
			for (int i = (int)_vec.size() - 1; i; i --) Push_Down(_vec[i]);
			return sgt[_vec.front()].dt;
		}
		template<class Compare>
		constexpr pair<int, Info> Find_Nxt(int l, int r, Info k, Compare comp) {
			_vec.clear(), vec.clear();
			Extract(l, r, 1, 0, n - 1);
			for (auto [p, L, R] : vec) {
				if (!comp(k, sgt[p].dt)) continue;
				while (L < R) {
					int Mid = (L + R) >> 1; Push_Down(p);
					if (comp(k, sgt[p << 1].dt)) R = Mid, p <<= 1;
					else L = Mid + 1, p = p << 1 | 1;
				}
				return {L, sgt[p].dt};
			}
			return {r + 1, Info()};
		}
		template<class Compare>
		constexpr pair<int, Info> Find_Pre(int l, int r, Info k, Compare comp) {
			_vec.clear(), vec.clear();
			Extract(l, r, 1, 0, n - 1);
			reverse(vec.begin(), vec.end());
			for (auto [p, L, R] : vec) {
				if (!comp(k, sgt[p].dt)) continue;
				while (L < R) {
					int Mid = (L + R) >> 1; Push_Down(p);
					if (!comp(k, sgt[p << 1 | 1].dt)) R = Mid, p <<= 1;
					else L = Mid + 1, p = p << 1 | 1;
				}
				return {L, sgt[p].dt};
			}
			return {l - 1, Info()};
		}
};
struct Info {
	Matrix prod[3];
	
	Info() { return; }
	friend Info operator + (Info x, Info y) {
		Info ans;
		for (int o : {0, 1, 2}) ans.prod[o] = x.prod[o] * y.prod[o];
		return ans;
	}
};
struct Tag {
	int tg;
	
	Tag(): tg(0) { return; }
	Tag(int _t): tg(_t) { return; }
	operator bool() {
		return tg;
	}
	friend Tag operator * (Tag x, Tag y) {
		return Tag((x.tg + y.tg) % 3);
	}
	Info Apply(Info x) {
		Info ans;
		for (int o : {0, 1, 2})
			ans.prod[o] = x.prod[(o + tg) % 3];
		return ans;
	}
};

constexpr int N = 5e5 + 5;
int n, q;
char s[N];
Segment_Tree<Info, Tag, N> sgt;
Matrix mp[3];

void slv() {
	for (int i : {0, 1, 2}) mp[i].Genshin();
	Read(n, q), Read(s);
	sgt.Build(n, [&](int i) {
		int x = s[i] - '0'; Info ans;
		for (int o : {0, 1, 2}) ans.prod[o] = mp[(o + x) % 3];
		return ans;
	});
	while (q --) {
		int opt, l, r; Read(opt, l, r);
		-- l, -- r;
		if (opt == 1) sgt.Update(l, r, Tag(1));
		else {
			auto ans = sgt.Query(l, r);
			for (int x : {0, 1}) for (int y : {0, 1})
				if (ans.prod[0].a[x][y] != (x == y)) { Puts("No"); goto END; }
			Puts("Yes"); END: {};
		}
	}
	return;
}
void clr() {

	return;
}
bool Med;
}

int main() {
#ifdef LOCAL
	freopen("!in.in", "r", stdin);
	freopen("!out.out", "w", stdout);
	fprintf(stderr, "%.3lf Mb\n", fabs((&Mbe - &Med) / 1048576.0));
#endif
	int T = 1;
//	int T = Read<int>();
	while (T --) slv(), clr();
#ifdef LOCAL
	fprintf(stderr, "%d ms\n", (int)clock());
#endif
	return 0;
}