#include <random>
#include <chrono>
#include <string>
#include <vector>
#include <algorithm>
#include <tuple>
#include <set>
#include <functional>
#include <cstring>

#include <vector>
#include <algorithm>
#include <cassert>
namespace exodus{
	namespace internal{
		class nothing{
		public:
			nothing(){}
			friend nothing operator +(const nothing&,const nothing&){return nothing();}
		};
	}
	template<class info=internal::nothing>
	struct dsu{
	public:
		struct node{
		public:
			node(){anc=-1,siz=1,ifo=info();}
			int anc,siz;
			info ifo;
		};
		dsu():_n(0){}
		explicit dsu(int n){
			_n=n;node.resize(n);
			for(int i=0;i<n;i++)
				node[i].anc=i;
		}
		void build(int n){
			_n=n;
			node.clear();
			node.resize(n);
			for(int i=0;i<n;i++)
				node[i].anc=i;
		}
		int find(int u){
			assert(0<=u&&u<_n);
			return __find(u);
		}
		void merge(int u,int v){
			assert(0<=u&&u<_n);
			assert(0<=v&&v<_n);
			u=__find(u),v=__find(v);
			if(node[u].siz<node[v].siz)std::swap(u,v);
			node[v].anc=u;
			node[u].ifo=node[u].ifo+node[v].ifo;
		}
		bool check(int u,int v){
			assert(0<=u&&u<_n);
			assert(0<=v&&v<_n);
			u=__find(u),v=__find(v);
			return u==v;
		}
	private:
		int _n;
		std::vector<node>node;
		int __find(int u){
			return u==node[u].anc?u:node[u].anc=__find(node[u].anc);
		}
	};
}


#include<string>
namespace exodus{
    namespace internal{
        const std::basic_string<char>Alpha{'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z'};
        const std::basic_string<char>alpha{'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
        const std::basic_string<char>digit{'0','1','2','3','4','5','6','7','8','9'};
    }
}


namespace exodus{
	using internal::Alpha;
    using internal::alpha;
    using internal::digit;
	struct randlib{
	public:
		randlib(long long seed=std::chrono::steady_clock::now().time_since_epoch().count()):g(seed){}
		/**
		 *  @brief This function returns a random integer in the range [l,r].
		 *  @param l The left bound of the value.
		 *  @param r The right bound of the value.
		*/
		template<typename T>
		T rnd(T l,T r){return std::uniform_int_distribution<T>(l,r)(g);}
		/**
		 *  @brief This function returns a random string of length len in the sigma character set.
		 *  @param len The length of the string.
		 *  @param sigma The character set.
		*/
		std::string rnd_string(const int len,const std::basic_string<char>&sigma){
			std::string result;
			result.resize(len);
			int sigma_size=sigma.size();
			for(auto &c:result)c=sigma[rnd<int>(0,sigma_size-1)];
			return result;
		}
		/**
		 *  @brief This function will return a tree with n vertices that has an expected tree height of O(log(n)).
		 *  @param n The number of node in tree.
		 *  @param unordered The function will shuffle the order of the nodes if unordered is true.
		*/
		std::vector<std::pair<int,int>>rnd_log_tree(int n,bool unordered=true){
			std::vector<std::pair<int,int>>result,edge;
			for(int i=1;i<n;i++)
				edge.emplace_back(i,rnd<int>(0,i-1));
			if(unordered){
				std::vector<int>ord(n);
				std::iota(ord.begin(),ord.end(),1);
				std::shuffle(ord.begin(),ord.end(),g);
				for(auto [u,v]:edge)
					result.emplace_back(ord[u],ord[v]);
			}else{
				std::vector<int>ord(n);
				std::iota(ord.begin(),ord.end(),1);
				for(auto [u,v]:edge)
					result.emplace_back(ord[u],ord[v]);
			}
			std::shuffle(result.begin(),result.end(),g);
			return result;
		}
		/**
		 *  @brief This function will return a weighted tree with n vertices that has an expected tree height of O(log(n)).
		 *  @param n The number of node in tree.
		 *  @param L The left bound of the weight.
		 *  @param R The right bound of the weight.
		 *  @param unordered The function will shuffle the order of the nodes if unordered is true.
		*/
		template<typename Weight>
		std::vector<std::tuple<int,int,Weight>>rnd_log_weighted_tree(int n,Weight L,Weight R,bool unordered=true){
			auto edge=rnd_log_tree(n,unordered);
			std::vector<std::tuple<int,int,Weight>>result;
			for(auto [u,v]:edge)result.emplace_back(u,v,rnd<Weight>(L,R));
			return result;
		}
		/**
		 *  @brief This function will return a tree with n vertices that has an expected tree height of O(sqrt(n)).
		 *  @param n The number of node in tree.
		 *  @param unordered The function will shuffle the order of the nodes if unordered is true.
		*/
		std::vector<std::pair<int,int>>rnd_sqrt_tree(int n,bool unordered=true){
			dsu dsu(n);
			std::vector<std::pair<int,int>>result,edge;
			for(;(int)edge.size()<n;){
				int u=rnd<int>(0,n-1),v=rnd<int>(0,n-1);
				if(dsu.check(u,v))continue;
				dsu.merge(u,v);
				edge.emplace_back(u,v);
			}
			if(unordered){
				std::vector<int>ord(n);
				std::iota(ord.begin(),ord.end(),1);
				for(auto [u,v]:edge)
					result.emplace_back(ord[u],ord[v]);
			}else{
				std::vector<std::vector<int>>e(n);
				for(auto [u,v]:edge)
					e[u].emplace_back(v),e[v].emplace_back(u);
				std::vector<int>ord(n);
				int ord_cnt=0;
				std::function<void(int)>dfs=[&](int u){
					ord[u]=++ord_cnt;
					for(auto v:e[u]){
						e[v].erase(std::find(e[v].begin(),e[v].end(),u));
						dfs(v);
					}
				};
				for(auto [u,v]:edge)
					result.emplace_back(ord[u],ord[v]);
			}
			std::shuffle(result.begin(),result.end(),g);
			return result;
		}
		/**
		 *  @brief This function will return a weighted tree with n vertices that has an expected tree height of O(sqrt(n)).
		 *  @param n The number of node in tree.
		 *  @param L The left bound of the weight.
		 *  @param R The right bound of the weight.
		 *  @param unordered The function will shuffle the order of the nodes if unordered is true.
		*/
		template<typename Weight>
		std::vector<std::tuple<int,int,Weight>>rnd_sqrt_weighted_tree(int n,Weight L,Weight R,bool unordered=true){
			auto edge=rnd_sqrt_tree(n,unordered);
			std::vector<std::tuple<int,int,Weight>>result;
			for(auto [u,v]:edge)result.emplace_back(u,v,rnd<Weight>(L,R));
			return result;
		}
		/**
		 *  @brief This function will return a tree with n vertices that has an expected tree height of O(n).
		 *  @param n The number of node in tree.
		 *  @param unordered The function will shuffle the order of the nodes if unordered is true.
		*/
		std::vector<std::pair<int,int>>rnd_linear_tree(int n,bool unordered=true){
			std::vector<std::pair<int,int>>edge,result;
			int dep=rnd<int>(n/3,2*n/3);
			for(int i=1;i<dep;i++)
				edge.emplace_back(i,i-1);
			for(int i=dep;i<n;i++)
				edge.emplace_back(i,rnd<int>(0,i-1));
			if(unordered){
				std::vector<int>ord(n);
				std::iota(ord.begin(),ord.end(),1);
				std::shuffle(ord.begin(),ord.end(),g);
				for(auto [u,v]:edge)
					result.emplace_back(ord[u],ord[v]);
			}else{
				std::vector<int>ord(n);
				std::iota(ord.begin(),ord.end(),1);
				for(auto [u,v]:edge)
					result.emplace_back(ord[u],ord[v]);
			}
			std::shuffle(result.begin(),result.end(),g);
			return result;
		}
		/**
		 *  @brief This function will return a tree with n vertices that has an expected tree height of O(n).
		 *  @param n The number of node in tree.
		 *  @param L The left bound of the weight.
		 *  @param R The right bound of the weight.
		 *  @param unordered The function will shuffle the order of the nodes if unordered is true.
		*/
		template<typename Weight>
		std::vector<std::tuple<int,int,Weight>>rnd_linear_weighted_tree(int n,Weight L,Weight R,bool unordered=true){
			auto edge=rnd_linear_tree(n,unordered);
			std::vector<std::tuple<int,int,Weight>>result;
			for(auto [u,v]:edge)result.emplace_back(u,v,rnd<Weight>(L,R));
			return result;
		}
		/**
		 *  @brief This function will return a graph with n vertices and m edges.
		 *  @param n The number of node in graph.
		 *  @param m The number of edge in graph.
		 *  @param connected The function will return a connected graph if connected is true.
		*/
		std::vector<std::pair<int,int>>rnd_graph(int n,int m,bool connected=true){
			std::vector<std::pair<int,int>>result;
			if(connected){
				assert(m>=n-1);
				auto edges=rnd_sqrt_tree(n);
				result=edges;
				std::set<std::pair<int,int>>visit;
				for(auto [u,v]:edges)
					visit.emplace(u,v),visit.emplace(v,u);
				for(int i=n,u,v;i<=m;i++){
					do{u=rnd(1,n),v=rnd(1,n);}while(!visit.count(std::make_pair(u,v)));
					visit.emplace(u,v),visit.emplace(v,u);
					result.emplace_back(u,v);
				}
				return result;
			}else{
				std::set<std::pair<int,int>>visit;
				for(int i=1,u,v;i<=m;i++){
					do{u=rnd(1,n),v=rnd(1,n);}while(!visit.count(std::make_pair(u,v)));
					visit.emplace(u,v),visit.emplace(v,u);
					result.emplace_back(u,v);
				}
				return result;
			}
		}
	private:
		std::mt19937_64 g;
	};
}



#include <vector>
#include <cassert>
#include <algorithm>
#include <cstdio>

namespace exodus{
    namespace internal{
        static constexpr int unroll_step=8;
        template<int R, int L = 0, int M = (L + R) / 2, class F>__attribute__((always_inline))
        inline void unroll(int i, F lambda) { if (R - L == 1)lambda(i + L); else unroll<M, L>(i, lambda), unroll<R, M>(i, lambda); }
    }
}


namespace exodus{
	typedef unsigned long long ull;
	template<typename T>
	struct base_matrix{
	public:
		base_matrix(){std::memset(mat,0,sizeof(mat));}
		explicit base_matrix(int _deg):deg(_deg){std::memset(mat,0,sizeof(mat));}
		T* operator [](int p){return mat[p];}
		const T* operator [](int p)const{return mat[p];}
		int get_deg()const{return deg;}
		void set_deg(int _deg){deg=_deg;std::memset(mat,0,sizeof(deg));}
		bool operator ==(const base_matrix& rhs){
			if(get_deg()!=rhs.get_deg())
				return false;
			for(int i=0;i<get_deg();i++)
				for(int j=0;j<get_deg();j++)
					if((*this)[i][j]!=rhs[i][j])
						return false;
			return true;
		}
		bool operator !=(const base_matrix& rhs){
			return !((*this)==rhs);
		}
	private:
		int deg;
		T mat[2][2];
	};
	template<unsigned int mod>
	struct mod_matrix:public base_matrix<int>{
	public:
		mod_matrix(){}
		explicit mod_matrix(int _deg):base_matrix<int>(_deg){}
		mod_matrix operator +(const mod_matrix& rhs)const{
			int deg=this->get_deg();
			mod_matrix res(deg);
			for(int i=0;i<deg;i++)
				for(int j=0;j<deg;j++)
					res[i][j]=(*this)[i][j]+rhs[i][j];
			return res;
		}
		mod_matrix operator *(const mod_matrix& rhs)const{
			int deg=this->get_deg();
			mod_matrix res(deg);
			for(int i=0;i<deg;i++)
				for(int k=0;k<deg;k++)
					for(int j=0;j<deg;j++)
						res[i][j]+=(*this)[i][k]*rhs[k][j];
			return res;
		}
		friend mod_matrix& operator +=(mod_matrix& lhs,const mod_matrix& rhs){
			lhs=lhs+rhs;
			return lhs;
		}
		friend mod_matrix& operator *=(mod_matrix& lhs,const mod_matrix& rhs){
			lhs=lhs*rhs;
			return lhs;
		}
		void print(){
			printf("mod_matrix\n");
			printf("============\n");
			int curdeg=this->get_deg();
			for(int i=0;i<curdeg;i++){
				for(int j=0;j<curdeg;j++)
					printf("%d ",(*this)[i][j]);
				printf("\n");
			}
			printf("============\n");
		}
	};
	template<typename T>
	struct base_vector{
	public:
		base_vector(){}
		explicit base_vector(int _deg,bool _tp):deg(_deg),tp(_tp){vec.resize(deg,T());}
		T& operator [](int p){return vec[p];}
		const T& operator [](int p)const{return vec[p];}
		int get_deg()const{return deg;}
		bool get_tp()const{return tp;}
		void set_deg(int _deg){
			deg=_deg;
			vec.resize(deg);
			fill(vec.begin(),vec.end(),T());
		}
	private:
		int deg;
		bool tp;
		std::vector<T>vec;
	};
	template<unsigned int mod>
	struct mod_vector:public base_vector<int>{
	public:
		mod_vector(){}
		explicit mod_vector(int _deg,bool _tp):base_vector<int>(_deg,_tp){}
		friend mod_vector operator +(const mod_vector& lhs,const mod_vector& rhs){
			assert(lhs.get_deg()==rhs.get_deg()&&lhs.get_tp()==rhs.get_tp());
			int deg=lhs.get_deg(),tp=lhs.get_tp();
			mod_vector res(deg,tp);
			auto add=[&](int& x,int y){x+=y-mod,x+=x>>31&mod;};
			int i=0;
			for(;i+internal::unroll_step-1<deg;i+=internal::unroll_step)
				internal::unroll<internal::unroll_step>(i,[&](int ci){add(res[ci]=lhs[ci],rhs[ci]);});
			while(i<deg)
				add(res[i]=lhs[i],rhs[i]),++i;
			return res;
		}
		friend mod_vector operator *(const mod_vector& lhs,const mod_matrix<mod>& rhs){
			if(lhs.get_tp()==0){
				const ull lim=16e18;
				assert(lhs.get_deg()==rhs.get_deg());
				int deg=lhs.get_deg();
				bool tp=lhs.get_tp();
				base_vector<ull>tmp(deg,tp);
				for(int k=0;k<deg;k++){
					int j=0;
					for(;j+internal::unroll_step-1<deg;j+=internal::unroll_step)
						internal::unroll<internal::unroll_step>(j,[&](int cj){tmp[cj]+=(ull)lhs[k]*rhs[k][cj];if(tmp[cj]>lim)tmp[cj]%=mod;});
					while(j<deg){
						tmp[j]+=(ull)lhs[k]*rhs[k][j];
						if(tmp[j]>lim)tmp[j]%=mod;
						++j;
					}
				}
				mod_vector res(deg,tp);
				for(int j=0;j<deg;j++)
					res[j]=tmp[j]%mod;
				return res;
			}else if(lhs.get_tp()==1){
				const ull lim=16e18;
				assert(lhs.get_deg()==rhs.get_deg());
				int deg=lhs.get_deg();
				bool tp=lhs.get_tp();
				base_vector<ull>tmp(deg,tp);
				for(int k=0;k<deg;k++){
					int j=0;
					for(;j+internal::unroll_step-1<deg;j+=internal::unroll_step)
						internal::unroll<internal::unroll_step>(j,[&](int cj){tmp[cj]+=(ull)lhs[k]*rhs[cj][k];if(tmp[cj]>lim)tmp[cj]%=mod;});
					while(j<deg){
						tmp[j]+=(ull)lhs[k]*rhs[j][k];
						if(tmp[j]>lim)tmp[j]%=mod;
						++j;
					}
				}
				mod_vector res(deg,tp);
				for(int j=0;j<deg;j++)
					res[j]=tmp[j]%mod;
				return res;
			}
		}
		friend mod_vector& operator +=(mod_vector& lhs,const mod_vector& rhs){
			lhs=lhs+rhs;
			return lhs;
		}
		friend mod_vector& operator *=(mod_vector& lhs,const mod_matrix<mod>& rhs){
			lhs=lhs*rhs;
			return lhs;
		}
		void print(){
			printf("mod_vector\n");
			printf("============\n");
			int curdeg=this->get_deg();
			for(int i=0;i<curdeg;i++){
				printf("%d ",(*this)[i]);
			}
			printf("\n");
			printf("============\n");
		}
	};
}


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

typedef long long ll;
typedef unsigned long long ull;
typedef double db;
typedef long double ldb;
typedef exodus::mod_matrix<998244353> matrix;

#define rep(i,l,r) for(int i(l);i<=(r);++i)
#define per(i,r,l) for(int i(r);i>=(l);--i)
#define eb emplace_back
#define File(filename) freopen(filename ".in","r",stdin),freopen(filename ".out","w",stdout)
#define Exit(p) fprintf(stderr,"[exit]: at breakpoint %d\n",p),exit(0);

#ifdef EXODUS
	#define Debug(...) fprintf(stderr,__VA_ARGS__)
#else
	#define Debug(...) 0
#endif

//=========================================================================================================
// Something about IO

template<typename T>
void read(T &x){
	x=0;T flg=1;
	char ch=getchar();
	while(!isdigit(ch)){if(ch=='-')flg=-1;ch=getchar();}
	while(isdigit(ch))x=(x<<3)+(x<<1)+(ch^48),ch=getchar();
	x*=flg;
}
template<typename T>
void seq_read(T bg,T ed){for(auto i=bg;i!=ed;++i)read(*i);}
template<typename T,typename... Args>
void read(T &x,Args &...args){read(x),read(args...);}

//=========================================================================================================
//Some useful function

template<typename T>
void cmax(T& x,T y){x=max(x,y);}
template<typename T,typename... Args>
void cmax(T& x,T y,Args ...args){cmax(x,y);cmax(x,args...);}
template<typename T>
void cmin(T& x,T y){x=min(x,y);}
template<typename T,typename... Args>
void cmin(T& x,T y,Args ...args){cmin(x,y);cmin(x,args...);}
template<typename T,typename U>
void seq_assign(T bg,T ed,U val){for(auto i=bg;i!=ed;++i)(*i)=val;}
template<typename T,class F,class=enable_if_t<is_invocable_v<F>>>
void seq_assign(T bg,T ed,F func){for(auto i=bg;i!=ed;++i)(*i)=func(i);}
template<typename T>
void seq_copy(T dstbg,T dsted,T srcbg,T srced){for(auto i=dstbg,j=srcbg;i!=dsted&&j!=srced;++i,++j)(*i)=(*j);}
matrix qpow(matrix b,int m){
	matrix res(b.get_deg());
	res[0][0]=res[1][1]=1;
	for(;m;m>>=1,b=b*b)
		if(m&1)res=res*b;
	return res;
}

//=========================================================================================================
// Define the global variables here.

bool membg=0;

constexpr int N=5e5+7;
constexpr int mod=998244353;
matrix e;
matrix mat[3],imat[3];
exodus::randlib gen(0);
int n,Q;
char s[N];
struct Sgt{
#define ls(k) ((k)<<1)
#define rs(k) ((k)<<1|1)
	struct node{
		matrix prod[3];
		int tag;
	}t[N<<2];
	void apply(int k,int v){
		rotate(t[k].prod,t[k].prod+v,t[k].prod+3);
		(t[k].tag+=v)%=3;
	}
	void pull(int k){
		for(int i=0;i<3;i++)
			t[k].prod[i]=t[ls(k)].prod[i]*t[rs(k)].prod[i];
	}
	void push(int k){
		if(t[k].tag){
			apply(ls(k),t[k].tag);
			apply(rs(k),t[k].tag);
			t[k].tag=0;
		}
	}
	void build(int k,int l,int r){
		t[k].tag=0;
		if(l==r){
			for(int i=0;i<3;i++)
				t[k].prod[i]=(l&1)?mat[i]:imat[i];
			apply(k,s[l]-'0');
			return;
		}
		int mid=(l+r)>>1;
		build(ls(k),l,mid);
		build(rs(k),mid+1,r);
		return pull(k);;
	}
	void modify(int k,int l,int r,int ql,int qr,int v){
		if(ql<=l&&r<=qr)
			return apply(k,v);
		int mid=(l+r)>>1;
		push(k);
		if(ql<=mid)
			modify(ls(k),l,mid,ql,qr,v);
		if(mid<qr)
			modify(rs(k),mid+1,r,ql,qr,v);
		return pull(k);
	}
	matrix query(int k,int l,int r,int ql,int qr){
		if(ql<=l&&r<=qr)
			return t[k].prod[0];
		int mid=(l+r)>>1;matrix res;
		push(k);
		if(ql<=mid){
			res=query(ls(k),l,mid,ql,qr);
			if(mid<qr)
				res=res*query(rs(k),mid+1,r,ql,qr);
		}else if(mid<qr){
			res=query(rs(k),mid+1,r,ql,qr);
		}
		return res;
	}
#undef ls
#undef rs
}sgt;

bool memed=0;

//=========================================================================================================
// Code here.

void generate(matrix& x,matrix& invx){
	x.set_deg(2),invx.set_deg(2);
	do{
		for(int i=0;i<2;i++)
			for(int j=0;j<2;j++)
				x[i][j]=gen.rnd(1,mod-1);
	}while(qpow(x,mod-1)!=e);
	invx=qpow(x,mod-2);
}

void solve(){
	e.set_deg(2);
	for(int i=0;i<2;i++)
		e[i][i]=1;
	for(int i=0;i<3;i++)
		generate(mat[i],imat[i]);
	read(n,Q);
	scanf("%s",s+1);
	sgt.build(1,1,n);
	// for(int i=0;i<3;i++)
	// 	(mat[i]*imat[i]).print();
	for(int qid=1,opt,l,r;qid<=Q;qid++){
		read(opt,l,r);
		if(opt==1){
			sgt.modify(1,1,n,l,r,1);
			// for(int i=l;i<=r;i++)
			// 	s[i]=(s[i]-'0'+1)%3+'0';
			// sgt.build(1,1,n);
		}else{
			// for(int i=l;i<=r;i++)
			// 	putchar(s[i]);
			// putchar('\n');
			printf(sgt.query(1,1,n,l,r)==e?"Yes\n":"No\n");
		}
	}
	return;
}


//=========================================================================================================

int main(){
	Debug("%.3lfMB\n",fabs(&memed-&membg)/1024.0/1024.0);
	int timbg=clock();
	int T=1;
	while(T--)solve();
	int timed=clock();
	Debug("%.3lfs\n",1.0*(timed-timbg)/CLOCKS_PER_SEC);
	fflush(stdout);
	return 0;
}