/*
lengli_QAQ
Hope there are no bugs!!!
*/
#include <bits/stdc++.h>
#define fastio ios::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define endl '\n'
#define all(x) x.begin(),x.end()
#define pb push_back

using namespace std;

//--------------------------------
template<typename T> void printvt(vector<T> &a){
	for(auto x:a) cout<<x<<" ";cout<<endl;
};
template<typename T> void printay(T a[],int l,int r){
	for(int i=l;i<=r;i++) cout<<a[i]<<" ";cout<<endl;
};
//--------------------------------

typedef pair<int,int> PII;
typedef long long LL;

template <unsigned M_> struct ModInt {
  static constexpr unsigned M = M_;
  unsigned x;
  constexpr ModInt() : x(0U) {}
  constexpr ModInt(unsigned x_) : x(x_ % M) {}
  constexpr ModInt(unsigned long long x_) : x(x_ % M) {}
  constexpr ModInt(int x_) : x(((x_ %= static_cast<int>(M)) < 0) ? (x_ + static_cast<int>(M)) : x_) {}
  constexpr ModInt(long long x_) : x(((x_ %= static_cast<long long>(M)) < 0) ? (x_ + static_cast<long long>(M)) : x_) {}
  ModInt &operator+=(const ModInt &a) { x = ((x += a.x) >= M) ? (x - M) : x; return *this; }
  ModInt &operator-=(const ModInt &a) { x = ((x -= a.x) >= M) ? (x + M) : x; return *this; }
  ModInt &operator*=(const ModInt &a) { x = (static_cast<unsigned long long>(x) * a.x) % M; return *this; }
  ModInt &operator/=(const ModInt &a) { return (*this *= a.inv()); }
  ModInt pow(long long e) const {
    if (e < 0) return inv().pow(-e);
    ModInt a = *this, b = 1U; for (; e; e >>= 1) { if (e & 1) b *= a; a *= a; } return b;
  }
  ModInt inv() const {
    unsigned a = M, b = x; int y = 0, z = 1;
    for (; b; ) { const unsigned q = a / b; const unsigned c = a - q * b; a = b; b = c; const int w = y - static_cast<int>(q) * z; y = z; z = w; }
    assert(a == 1U); return ModInt(y);
  }
  ModInt operator+() const { return *this; }
  ModInt operator-() const { ModInt a; a.x = x ? (M - x) : 0U; return a; }
  ModInt operator+(const ModInt &a) const { return (ModInt(*this) += a); }
  ModInt operator-(const ModInt &a) const { return (ModInt(*this) -= a); }
  ModInt operator*(const ModInt &a) const { return (ModInt(*this) *= a); }
  ModInt operator/(const ModInt &a) const { return (ModInt(*this) /= a); }
  template <class T> friend ModInt operator+(T a, const ModInt &b) { return (ModInt(a) += b); }
  template <class T> friend ModInt operator-(T a, const ModInt &b) { return (ModInt(a) -= b); }
  template <class T> friend ModInt operator*(T a, const ModInt &b) { return (ModInt(a) *= b); }
  template <class T> friend ModInt operator/(T a, const ModInt &b) { return (ModInt(a) /= b); }
  explicit operator bool() const { return x; }
  bool operator==(const ModInt &a) const { return (x == a.x); }
  bool operator!=(const ModInt &a) const { return (x != a.x); }
  bool operator<(const ModInt &a) const { return (x < a.x); }
  bool operator>(const ModInt &a) const { return (x > a.x); }
  bool operator<=(const ModInt &a) const { return (x <= a.x); }
  bool operator>=(const ModInt &a) const { return (x >= a.x); }
  friend std::ostream &operator<<(std::ostream &os, const ModInt &a) { return os << a.x; }
  friend std::istream &operator>>(std::istream &is, ModInt &a) {int v;is >> v;a = ModInt(v);return is;}
};
constexpr unsigned M = 1000000007;
using Mint = ModInt<M>;

template<typename T> struct matrix {
	int n, m;
	std::vector<T> data;
	matrix () : matrix(0, 0) {}
	matrix (int n) : matrix(n, n) {}
	matrix (int n, int m) : n(n), m(m), data(n * m) {}
	matrix (const std::vector<std::vector<T> > &a) : n(a.size()), m(a[0].size()) {
		data.resize(n*m);
		for (int i = 0; i < n; i++) {
			copy(a[i].begin(), a[i].end(), data.begin()+i*m);
		}
	}
	auto operator [] (int i) { return data.begin() + i * m; }
	auto operator [] (int i) const { return data.cbegin() + i * m; }
	static matrix mul_ident(int n) {
		matrix res(n, n);
		for (int i = 0; i < n; i++) res[i][i] = 1;
		return res;
	}
	matrix operator + (const matrix &rhs) {
		assert(n == rhs.n && m == rhs.m);
		matrix res(n,m);
		for (int i = 0; i < n ; i++) {
			for (int j = 0; j < m; j++)
				res[i][j] = (*this)[i][j] + rhs[i][j];
		}
		return res;
	}
	matrix operator - (const matrix &rhs) {
		assert(n == rhs.n && m == rhs.m);
		matrix res(n,m);
		for (int i = 0; i < n ; i++) {
			for (int j = 0; j < m; j++)
				res[i][j] = (*this)[i][j] - rhs[i][j];
		}
		return res;
	}
	matrix operator * (const matrix &rhs) {
		assert(m == rhs.n);
		matrix res(n, rhs.m);
		for (int i = 0; i < n; i++) for (int j = 0; j < m; j++) for (int k = 0; k < rhs.m; k++)
			res[i][k] += (*this)[i][j] * rhs[j][k];
		return res;
	}
	template<typename int_t> matrix operator ^ (int_t x) {
		assert(n == m);
		matrix res = mul_ident(n);
		while (x) {
			if (x & 1) res = matrix(*this)*res;
			*this = matrix(*this)*matrix(*this);
			x>>=1;
		}
		return res;
	}
	matrix &operator += (const matrix &rhs) { return *this = *this + rhs;}
	matrix &operator -= (const matrix &rhs) { return *this = *this - rhs;}
	matrix &operator *= (const matrix &rhs) { return *this = *this * rhs;}
	template<typename int_t> matrix &operator ^= (int_t x) { return *this = *this ^ x;}
	bool operator == (const matrix &rhs) const { return m == rhs.m && data == rhs.data; }
	bool operator != (const matrix &rhs) const { return m != rhs.m || data != rhs.data; }
	std::pair<bool, matrix> inv() {
		assert(n == m);
		matrix a = *this;
		matrix r = mul_ident(n);
		for (int i = 0; i < n; i++) {
			int id = -1;
			for (int j = i; j < n; j++) if (a[j][i] != T(0)) { id = j; break; }
			if (id == -1) return {false, matrix()};
			for (int j = i; j < n; j++) std::swap(a[i][j], a[id][j]);
			for (int j = 0; j < n; j++) std::swap(r[i][j], r[id][j]);
			auto t = T(1) / a[i][i];
			for (int j = i; j < n; j++) a[i][j] *= t;
			for (int j = 0; j < n; j++) r[i][j] *= t;
			for (int j = 0; j < n; j++) if (i != j) {
				auto s = a[j][i];
				for (int k = i; k < n; k++) a[j][k] -= a[i][k] * s;
				for (int k = 0; k < n; k++) r[j][k] -= r[i][k] * s;
			}
		}
		return {true, r};
	}
	std::pair<bool, matrix> inv2() {
		assert(n == m);
		matrix a = *this;
		std::vector<std::pair<int, int> > swaps;
		for (int i = 0; i < n; i++) {
			int id = -1;
			for (int j = i; j < n; j++) if (a[j][i] != T(0)) { id = j; break; }
			if (id == -1) return {false, matrix()};
			if (id != i) {
				swaps.push_back({id, i});
				for (int j = 0; j < n; j++) std::swap(a[i][j], a[id][j]);
			}
			a[i][i] =  T(1) / a[i][i];
			for (int j = 0; j < n; j++) if (j != i) a[i][j] *= a[i][i];
			for (int j = 0; j < n; j++) if (j != i) {
				for (int k = 0; k < n; k++) if (k != i) a[j][k] -= a[j][i] * a[i][k];
				a[j][i] *= -a[i][i];
			}
		}
		for (int i = swaps.size(); i--; ) 
			for (int j = 0; j < n; j++) std::swap(a[j][swaps[i].first], a[j][swaps[i].second]);
		return {true, a};
	}
	T det() const {
		assert(n == m);
		matrix a = *this;
		T res = 1;
		for (int i = 0; i < n; i++) {
			int id = -1;
			for (int j = i; j < n; j++) if (a[j][i] != T(0)) { id = j; break; }
			if (id == -1) return 0;
			if (id != i) {
				res = -res;
				for (int j = i; j < n; j++) std::swap(a[id][j], a[i][j]);
			}
			res *= a[i][i];
			
			T t = T(1) / a[i][i];
			for (int j = i; j < n; j++) a[i][j] *= t;
			for (int j = i + 1; j < n; j++) {
				auto s = a[j][i];
				for (int k = i; k < n; k++) a[j][k] -= a[i][k] * s;
			}
		}
		return res;
	}
};

const int N=500010;

int n,q;
int a[N];

matrix<Mint> base[3],_base[3];

struct Node{
	int l,r;
	matrix<Mint> v[3];
	int add;
}tr[N*4];

void pushup(Node &u,Node l,Node r){
	for(int i=0;i<3;i++) u.v[i]=l.v[i]*r.v[i];
}

void pushup(int u){
	pushup(tr[u],tr[u<<1],tr[u<<1|1]);
}

void pushdown(int u){
	if(!tr[u].add) return;
	tr[u<<1].add+=tr[u].add,tr[u<<1].add%=3;
	tr[u<<1|1].add+=tr[u].add,tr[u<<1|1].add%=3;
	tr[u].add%=3;
	while(tr[u].add>0){
		swap(tr[u<<1].v[0],tr[u<<1].v[1]);
		swap(tr[u<<1].v[1],tr[u<<1].v[2]);
		swap(tr[u<<1|1].v[0],tr[u<<1|1].v[1]);
		swap(tr[u<<1|1].v[1],tr[u<<1|1].v[2]);
		tr[u].add--;
	}
}

void build(int u,int l,int r){
	tr[u].l=l,tr[u].r=r;
	if(l==r) {
		if(l&1){
			for(int i=0;i<3;i++)
				tr[u].v[i]=_base[(a[l]+i)%3];
		}else{
			for(int i=0;i<3;i++)
				tr[u].v[i]=base[(a[l]+i)%3];
		}
	}else{
		int mid=(l+r)/2;
		build(u<<1,l,mid);
		build(u<<1|1,mid+1,r);
		pushup(u);
	}
}

void modify(int u,int l,int r){
	if(tr[u].l>=l and tr[u].r<=r){
		tr[u].add+=1;
		swap(tr[u].v[0],tr[u].v[1]);
		swap(tr[u].v[1],tr[u].v[2]);
		return;
	}
	pushdown(u);
	int mid=(tr[u].l+tr[u].r)/2;
	if(l<=mid) modify(u<<1,l,r);
	if(r>mid) modify(u<<1|1,l,r);
	pushup(u);
}

Node query(int u,int l,int r){
	if(tr[u].l>=l and tr[u].r<=r) return tr[u];
	int mid=(tr[u].l+tr[u].r)/2;
	pushdown(u);
	if(r<=mid) return query(u<<1,l,r);
	else if(l>mid) return query(u<<1|1,l,r);
	else{
		Node res;
		pushup(res,query(u<<1,l,r),query(u<<1|1,l,r));
		return res;
	}
}

mt19937 rd(time(0));

void solve(){
	cin>>n>>q;
	for(int i=1;i<=n;i++){
		char c;
		cin>>c;
		a[i]=c-'0';
	}
	
	for(int i=0;i<3;i++){
		matrix<Mint> k(2);
		for(auto &x:k.data) x=Mint((LL)rd());
		base[i]=k;
		auto res=k.inv2();
		assert(res.first==1);
		_base[i]=res.second;
	}
	
	build(1,1,n);
	
	matrix<Mint> E({{1,0},{0,1}});
	while(q--){
		int op,l,r;
		cin>>op>>l>>r;
		if(op==1){
			modify(1,l,r);
		}else{
			auto t=query(1,l,r);
			if(t.v[0]==E) cout<<"Yes"<<endl;
			else cout<<"No"<<endl;
		}
	}
	
}

signed main(){
    fastio;
    
    int T;
    T=1;
    while(T--) solve();
    
    return 0;
}