/*
 * @Author:             cmk666
 * @Created time:       2023-07-10 16:19:54
 * @Last Modified time: 2023-07-10 16:59:35
 */
#pragma GCC optimize("Ofast", "unroll-loops")
#include<bits/stdc++.h>
using namespace std; using ll = long long;
#define For(i, j, k) for ( int i = (j) ; i <= (k) ; i++ )
#define Fol(i, j, k) for ( int i = (j) ; i >= (k) ; i-- )
namespace FastIO
{
// ------------------------------
// #define IN_HAS_NEG
// #define OUT_HAS_NEG
// #define CHK_EOF
// ------------------------------
#if __cplusplus < 201400
#error Please use C++14 or higher.
#endif
#define IL inline __attribute__((always_inline))
#ifndef _WIN32
#include<sys/mman.h>
#include<fcntl.h>
#endif
#ifdef LOCAL
	IL void gc(char &c) { c = getchar(); }
	IL void pc(const char &c) { putchar(c); }
#else
	IL void gc(char &c)
	{
#ifdef _WIN32
		constexpr int IN_SIZE = 1 << 18; static char i[IN_SIZE], *p = i, *q = i;
		if ( __builtin_expect(p == q, false) )
		{
			q = i + fread(p = i, 1, IN_SIZE, stdin);
#ifdef CHK_EOF
			if ( __builtin_expect(p == q, false) ) { c = EOF; return; }
#endif
		}
#else
		static char *p = (char *)mmap(0, INT_MAX, 1, 1, fileno(stdin), 0);
#endif
		c = *p++;
	}
	IL void pc(const char &c)
	{
		constexpr int OUT_SIZE = 1 << 13; static char o[OUT_SIZE], *p = o;
		if ( __builtin_expect(c == EOF, false) ) { fwrite(o, 1, p - o, stdout); return; }
		*p++ = c;
		if ( __builtin_expect(o + OUT_SIZE == p, false) ) fwrite(o, 1, p - o, stdout), p = o;
	}
	struct _auto_flush { ~_auto_flush() { pc(EOF); } } _auto_flusher;
#endif
#ifdef CHK_EOF
	IL bool _isdigit(const char &c) { return ( c & 16 ) && c != EOF; }
	IL bool _isgraph(const char &c) { return c > 32 && c != EOF; }
#else
	IL bool _isdigit(const char &c) { return c & 16; }
	IL bool _isgraph(const char &c) { return c > 32; }
#endif
	IL void read(char &c) { gc(c); while ( !_isgraph(c) ) gc(c); }
	IL void read_cstr(char *s)
	{
		char c; gc(c);
		while ( !_isgraph(c) ) gc(c);
		while ( _isgraph(c) ) *s++ = c, gc(c);
		*s = 0;
	}
	IL void read(string &s)
	{
		char c; gc(c), s.clear();
		while ( !_isgraph(c) ) gc(c);
		while ( _isgraph(c) ) s.push_back(c), gc(c);
	}
	template < class T, typename enable_if < is_integral < T >::value, int >::type = 0 >
	IL void uread(T &x)
	{
		char c; x = 0, gc(c);
		while ( !_isdigit(c) ) gc(c);
		while ( _isdigit(c) ) x = x * 10 + ( c & 15 ), gc(c);
	}
	IL void uread(__int128 &x)
	{
		char c; x = 0, gc(c);
		while ( !_isdigit(c) ) gc(c);
		while ( _isdigit(c) ) x = x * 10 + ( c & 15 ), gc(c);
	}
	IL void uread(__uint128_t &x)
	{
		char c; x = 0, gc(c);
		while ( !_isdigit(c) ) gc(c);
		while ( _isdigit(c) ) x = x * 10 + ( c & 15 ), gc(c);
	}
	template < class T, typename enable_if < is_unsigned < T >::value, int >::type = 0 >
	IL void read(T &x) { uread(x); }
	IL void read(__uint128_t &x) { uread(x); }
	template < class T, typename enable_if < is_signed < T >::value, int >::type = 0 >
	IL void read(T &x)
	{
#ifdef IN_HAS_NEG
		char c; bool flag = false; x = 0, gc(c);
		while ( !_isdigit(c) ) flag |= c == 45, gc(c);
		while ( _isdigit(c) ) x = x * 10 + ( c & 15 ), gc(c);
		if ( flag ) x = -x;
#else
		uread(x);
#endif
	}
	IL void read(__int128 &x)
	{
#ifdef IN_HAS_NEG
		char c; bool flag = false; x = 0, gc(c);
		while ( !_isdigit(c) ) flag |= c == 45, gc(c);
		while ( _isdigit(c) ) x = x * 10 + ( c & 15 ), gc(c);
		if ( flag ) x = -x;
#else
		uread(x);
#endif
	}
	template < int N, class ...T > struct _tuple_reader
	{ static IL void _read(tuple < T... > &x) { _tuple_reader < N - 1, T... >::_read(x), read(get < N - 1 > (x)); } };
	template < class ...T > struct _tuple_reader < 0, T... > { static IL void _read(tuple < T... > &x) {} };
	template < class ...T > IL void read(tuple < T... > &x) { _tuple_reader < sizeof...(T), T... >::_read(x); }
	template < class T, class TT > IL void read(pair < T, TT > &x) { read(x.first), read(x.second); }
	template < class T, class ...TT > IL void read(T &x, TT &...y) { read(x), read(y...); }
	template < class T, class ...TT > IL void uread(T &x, TT &...y) { uread(x), uread(y...); }
	template < class ...TT > IL void read_cstr(char *x, TT *...y) { read_cstr(x), read_cstr(y...); }
	IL void write(const char &c) { pc(c); }
	IL void write_cstr(const char *s) { while ( *s ) pc(*s++); }
	IL void write(const string &s) { for ( char c : s ) pc(c); }
	template < class T, typename enable_if < is_integral < T >::value, int >::type = 0 >
	inline void uwrite(const T &x) { if ( x > 9 ) uwrite(x / 10); pc(( x % 10 ) | 48); }
	inline void uwrite(const __int128 &x) { if ( x > 9 ) uwrite(x / 10); pc(( x % 10 ) | 48); }
	inline void uwrite(const __uint128_t &x) { if ( x > 9 ) uwrite(x / 10); pc(( x % 10 ) | 48); }
	template < class T, typename enable_if < is_unsigned < T >::value, int >::type = 0 >
	IL void write(const T &x) { uwrite(x); }
	IL void write(const __uint128_t &x) { uwrite(x); }
	template < class T, typename enable_if < is_signed < T >::value, int >::type = 0 >
	IL void write(const T &x)
	{
#ifdef OUT_HAS_NEG
		if ( x < 0 ) { pc(45); uwrite(-x); return; }
#endif
		uwrite(x);
	}
	IL void write(const __int128 &x)
	{
#ifdef OUT_HAS_NEG
		if ( x < 0 ) { pc(45); uwrite(-x); return; }
#endif
		uwrite(x);
	}
	template < int N, class ...T > struct _tuple_writer
	{ static IL void _write(const tuple < T... > &x) { _tuple_writer < N - 1, T... >::_write(x), write(N == 1 ? ""s : " "s), write(get < N - 1 > (x)); } };
	template < class ...T > struct _tuple_writer < 0, T... > { static IL void _write(const tuple < T... > &x) {} };
	template < class ...T > IL void write(const tuple < T... > &x) { _tuple_writer < sizeof...(T), T... >::_write(x); }
	template < class T, class TT > IL void write(const pair < T, TT > &x) { write(x.first), write(' '), write(x.second); }
	template < class T, class ...TT > IL void write(const T &x, const TT &...y) { write(x), write(y...); }
	template < class T, class ...TT > IL void uwrite(const T &x, const TT &...y) { uwrite(x), uwrite(y...); }
	template < class ...TT > IL void write_cstr(const char *x, const TT *...y) { write_cstr(x), write_cstr(y...); }
	template < class T > IL void print(const T &x) { write(x); }
	template < class T > IL void uprint(const T &x) { uwrite(x); }
	IL void print_cstr(const char *x) { write_cstr(x); }
	template < class T, class ...TT > IL void print(const T &x, const TT &...y) { write(x, ' '), print(y...); }
	template < class T, class ...TT > IL void uprint(const T &x, const TT &...y) { uwrite(x), write(' '), uprint(y...); }
	template < class ...TT > IL void print_cstr(const char *x, const TT *...y) { write_cstr(x), write(' '), print_cstr(y...); }
	IL void println() { write('\n'); }
	IL void uprintln() { write('\n'); }
	IL void println_cstr() { write('\n'); }
	template < class ...T > IL void println(const T &...x) { print(x...), write('\n'); }
	template < class ...T > IL void uprintln(const T &...x) { uprint(x...), write('\n'); }
	template < class ...T > IL void println_cstr(const T *...x) { print_cstr(x...), write('\n'); }
}
using namespace FastIO;
template < int mod > class Modint
{
	static inline int add(int x, int y) { return x + y < mod ? x + y : x + y - mod; }
	static inline int dec(int x, int y) { return x >= y ? x - y : x + mod - y; }
	static inline int mul(int x, int y) { return (ll)x * y % mod; }
	static inline int mod_it(int x) { return add(x % mod, mod); }
public:
	int v;
	Modint() : v(0) {}
	Modint(const Modint &x) : v(x.v) {}
	Modint(int x) : v(mod_it(x)) {}
	Modint(ll x) : v(add(x % mod, mod)) {}
	inline operator int()const { return v; }
	inline bool operator==(const Modint &x)const { return v == x.v; }
	inline bool operator==(int x)const { return v == mod_it(x); }
	inline bool operator!=(const Modint &x)const { return v != x.v; }
	inline bool operator!=(int x)const { return v != mod_it(x); }
	inline Modint &operator=(const Modint &x) { v = x.v; return *this; }
	inline Modint &operator=(int x) { v = mod_it(x); return *this; }
	inline Modint &operator++() { v = add(v, 1); return *this; }
	inline Modint operator++(int) { Modint x = *this; v = add(v, 1); return x; }
	inline Modint operator+(const Modint &x)const { return add(v, x.v); }
	inline Modint operator+(int x)const { return add(v, mod_it(x)); }
	inline friend Modint operator+(int x, const Modint &y) { return add(x, y.v); }
	inline Modint &operator+=(const Modint &x) { v = add(v, x.v); return *this; }
	inline Modint &operator+=(int x) { v = add(v, mod_it(x)); return *this; }
	inline Modint operator-()const { return v ? mod - v : 0; }
	inline Modint &operator--() { v = dec(v, 1); return *this; }
	inline Modint operator--(int) { Modint x = *this; v = dec(v, 1); return x; }
	inline Modint operator-(const Modint &x)const { return dec(v, x.v); }
	inline Modint operator-(int x)const { return dec(v, mod_it(x)); }
	inline friend Modint operator-(int x, const Modint &y) { return dec(x, y.v); }
	inline Modint &operator-=(const Modint &x) { v = dec(v, x.v); return *this; }
	inline Modint &operator-=(int x) { v = dec(v, mod_it(x)); return *this; }
	inline Modint operator*(const Modint &x)const { return mul(v, x.v); }
	inline Modint operator*(int x)const { return mul(v, mod_it(x)); }
	inline friend Modint operator*(int x, const Modint &y) { return mul(x, y.v); }
	inline Modint &operator*=(const Modint &x) { v = mul(v, x.v); return *this; }
	inline Modint &operator*=(int x) { v = mul(v, mod_it(x)); return *this; }
	inline Modint qpow(int y)const
	{
		Modint x = *this, z = 1;
		for ( ; y ; y >>= 1 ) { if ( y & 1 ) z *= x; x *= x; }
		return z;
	}
	inline Modint inv()const { return qpow(mod - 2); }
	inline Modint operator/(const Modint &x)const { return mul(v, x.inv()); }
	inline Modint operator/(int x)const { return mul(v, Modint(x).inv()); }
	inline friend Modint operator/(int x, const Modint &y) { return mul(x, y.inv()); }
	inline Modint &operator/=(const Modint &x) { v = mul(v, x.inv()); return *this; }
	inline Modint &operator/=(int x) { v = mul(v, Modint(x).inv()); return *this; }
};
template < int m > inline Modint < m > qpow(const Modint < m > &x, int y) { return x.qpow(y); }
template < int m > inline Modint < m > inv(const Modint < m > &x) { return x.inv(); }
constexpr int mod = 1011451423;
using MI = Modint < mod >;
mt19937 rnd(chrono::system_clock::now().time_since_epoch().count());
uniform_int_distribution uid(1, mod - 1);
struct mat
{
	MI a00, a01, a10, a11;
	mat(MI a00 = 0, MI a01 = 0, MI a10 = 0, MI a11 = 0) : a00(a00), a01(a01), a10(a10), a11(a11) {}
	inline bool isid()const { return a00 == 1 && a01 == 0 && a10 == 0 && a11 == 1; }
	inline mat operator*(const mat &x)const
	{
		return mat(a00 * x.a00 + a01 * x.a10, a00 * x.a01 + a01 * x.a11,
				   a10 * x.a00 + a11 * x.a10, a10 * x.a01 + a11 * x.a11);
	}
	inline mat &operator*=(const mat &x) { return *this = *this * x; }
	inline mat qpow(int y)const
	{
		mat x = *this, z(1, 0, 0, 1);
		for ( ; y ; y >>= 1 ) { if ( y & 1 ) z *= x; x *= x; }
		return z;
	}
	inline mat r()const { return qpow(mod - 2); }
	inline void random()
	{
		do a00 = uid(rnd), a01 = uid(rnd), a10 = uid(rnd), a11 = uid(rnd);
		while ( !qpow(mod - 1).isid() );
	}
}	a[3], b[3];
namespace ST
{
	struct node
	{
		mat v[3]; int lz;
		node() : lz(0) {}
		inline void apply(int x) { rotate(v, v + x, v + 3); if ( ( lz += x ) > 2 ) lz -= 3; }
	}	t[500009 << 2];
	inline node merge(const node &x, const node &y) { node z; For(i, 0, 2) z.v[i] = x.v[i] * y.v[i]; return z; }
	inline int lc(int x) { return x << 1; }
	inline int rc(int x) { return lc(x) | 1; }
	inline int md(int x, int y) { return ( x + y ) >> 1; }
	inline void pu(int p) { t[p] = merge(t[lc(p)], t[rc(p)]); }
	inline void pd(int p) { if ( t[p].lz ) t[lc(p)].apply(t[p].lz), t[rc(p)].apply(t[p].lz), t[p].lz = 0; }
	inline void build(int p, int l, int r, char *s)
	{
		if ( l == r ) { copy(l & 1 ? a : b, l & 1 ? a + 3 : b + 3, t[p].v), t[p].apply(s[l] - '0'); return; }
		build(lc(p), l, md(l, r), s), build(rc(p), md(l, r) + 1, r, s), pu(p);
	}
	inline void modify(int p, int l, int r, int lp, int rp)
	{
		if ( l > rp || r < lp ) return;
		if ( lp <= l && r <= rp ) { t[p].apply(1); return; }
		pd(p), modify(lc(p), l, md(l, r), lp, rp), modify(rc(p), md(l, r) + 1, r, lp, rp), pu(p);
	}
	inline mat query(int p, int l, int r, int lp, int rp)
	{
		if ( l > rp || r < lp ) return mat(1, 0, 0, 1);
		if ( lp <= l && r <= rp ) return t[p].v[0];
		return pd(p), query(lc(p), l, md(l, r), lp, rp) * query(rc(p), md(l, r) + 1, r, lp, rp);
	}
}
int n, q, op, l, r; char s[500009];
int main()
{
	For(i, 0, 2) a[i].random(), b[i] = a[i].r();
	read(n, q), read_cstr(s + 1), ST::build(1, 1, n, s);
	For(_, 1, q)
	{
		read(op, l, r);
		if ( op == 1 ) ST::modify(1, 1, n, l, r);
		else println(ST::query(1, 1, n, l, r).isid() ? "Yes"s : "No"s);
	}
	return 0;
}
// 想上IM捏 想上IM捏 想上IM捏 想上IM捏 想上IM捏