#include<bits/stdc++.h>
using namespace std;
#define debug(fmt,...) \
    fprintf(stderr, fmt,##__VA_ARGS__)
#define debugln(fmt,...) \
    fprintf(stderr,"[%d]" fmt,__LINE__,##__VA_ARGS__)
#define TIME (1e3*clock()/CLOCKS_PER_SEC)
typedef long long ll;
template<typename T,typename TT> void chkmin(T &x,TT y) {if(x>y) x=y;}
template<typename T,typename TT> void chkmax(T &x,TT y) {if(x<y) x=y;}
constexpr int mod=998244353;
void inc(int &x,int y) {x+=y; x-=(x>=mod)*mod;}
void dec(int &x,int y) {x-=y; x+=(x<0)*mod;}
constexpr int add(int x,int y) {return (x+y>=mod)?x+y-mod:x+y;}
constexpr int sub(int x,int y) {return (x<y)?x-y+mod:x-y;}
constexpr int quick_pow(int x,ll times,int ret=1) {
    for(;times;times>>=1,x=1ll*x*x%mod) if(times&1) ret=1ll*ret*x%mod;
    return ret;
}
bool memBeg;
constexpr int siz=2;
struct matrix {
    int a[siz][siz];
    matrix() {memset(a,0,sizeof(a));}
    int *operator[](int i) {return a[i];}
    const int *operator[](int i) const {return a[i];}
    matrix operator*(const matrix &o) const {
        matrix ret;
        for(int i=0;i<siz;i++) {
            for(int j=0;j<siz;j++) {
                if(a[i][j]) {
                    for(int k=0;k<siz;k++) {
                        ret[i][k]=(ret[i][k]+1ll*a[i][j]*o.a[j][k])%mod;
                    }
                }
            }
        }
        return ret;
    }
};
bool check(const matrix &o) {
    for(int i=0;i<siz;i++) {
        for(int j=0;j<siz;j++) {
            if(o[i][j]!=(i==j)) return false;
        }
    }
    return true;
}
matrix inv(const matrix &o) {
    matrix run=o,ret;
    for(int i=0;i<siz;i++) ret[i][i]=1;
    for(int i=0;i<siz;i++) {
        if(!run[i][i]) {
            int key=-1;
            for(int j=i+1;j<siz;j++) {
                if(run[j][i]) {
                    key=j; break;
                }
            }
            if(key==-1) {
                ret[0][0]=-1; return ret;
            }
            for(int j=i;j<siz;j++) swap(run[i][j],run[key][j]);
            for(int j=0;j<siz;j++) swap(ret[i][j],ret[key][j]);
        }
        int inv=mod-quick_pow(run[i][i],mod-2);
        for(int j=i+1;j<siz;j++) {
            int coef=1ll*run[j][i]*inv%mod;
            for(int k=i;k<siz;k++) run[j][k]=(run[j][k]+1ll*run[i][k]*coef)%mod;
            for(int k=0;k<siz;k++) ret[j][k]=(ret[j][k]+1ll*ret[i][k]*coef)%mod;
        }
    }
    for(int i=siz-1;i>=0;i--) {
        for(int j=i+1;j<siz;j++) {
            int coef=sub(0,run[i][j]);
            run[i][j]=0;
            for(int k=0;k<siz;k++) ret[i][k]=(ret[i][k]+1ll*ret[j][k]*coef)%mod;
        }
        int inv=quick_pow(run[i][i],mod-2);
        run[i][i]=1;
        for(int j=0;j<siz;j++) ret[i][j]=1ll*ret[i][j]*inv%mod;
    }
    assert(check(run));
    return ret;
}
mt19937 eng(19260817);
template<typename T> T get_rand(T l,T r) {
    return uniform_int_distribution<T>(l,r)(eng);
}
matrix m[3],mi[3];
constexpr int maxn=5e5+5;
int n,Q;
char s[maxn];
struct node {
    matrix p[3];
    matrix& operator[](int i) {return p[i];}
    const matrix& operator[](int i) const {return p[i];}
    node operator+(const node &o) const {
        node ret;
        for(int i=0;i<3;i++) ret[i]=p[i]*o[i];
        return ret;
    }
};
struct segment_tree {
    node tree[maxn<<2];
    int tag[maxn<<2];
    void push_up(int cur) {
        tree[cur]=tree[cur<<1]+tree[cur<<1|1];
    }
    void build(int tl,int tr,int cur) {
        if(tl==tr) {
            if(tl&1) {
                for(int i=0;i<3;i++) tree[cur][i]=m[(s[tl]-'0'+i)%3];
            } else {
                for(int i=0;i<3;i++) tree[cur][i]=mi[(s[tl]-'0'+i)%3];
            }
            return;
        }
        int mid=(tl+tr)>>1;
        build(tl,mid,cur<<1);
        build(mid+1,tr,cur<<1|1);
        push_up(cur);
    }
    void dtag(int cur,int _tag) {
        tag[cur]=(tag[cur]+_tag)%3;
        rotate(tree[cur].p,tree[cur].p+_tag,tree[cur].p+3);
    }
    void push_down(int cur) {
        if(tag[cur]) {
            dtag(cur<<1,tag[cur]);
            dtag(cur<<1|1,tag[cur]);
            tag[cur]=0;
        }
    }
    void modify(int tl,int tr,int cur,int l,int r) {
        if(l<=tl&&tr<=r) return dtag(cur,1);
        push_down(cur);
        int mid=(tl+tr)>>1;
        if(l<=mid) modify(tl,mid,cur<<1,l,r);
        if(r>mid) modify(mid+1,tr,cur<<1|1,l,r);
        push_up(cur);
    }
    matrix query(int tl,int tr,int cur,int l,int r) {
        if(l<=tl&&tr<=r) return tree[cur][0];
        push_down(cur);
        int mid=(tl+tr)>>1;
        if(l>mid) return query(mid+1,tr,cur<<1|1,l,r);
        else if(r<=mid) return query(tl,mid,cur<<1,l,r);
        else return query(tl,mid,cur<<1,l,r)*
                    query(mid+1,tr,cur<<1|1,l,r);
    }
}T;
bool memEn;
int main() {
    debug("%.24lf\n",fabs(&memEn-&memBeg)/1024.0/1024.0);
    for(int i=0;i<3;i++) {
        do {
            for(int j=0;j<siz;j++) {
                for(int k=0;k<siz;k++) m[i][j][k]=get_rand(1,mod-1);
            }
            mi[i]=inv(m[i]);
        }while(mi[i][0][0]==-1);
        matrix chk=m[i]*mi[i];
        assert(check(chk));
        chk=mi[i]*m[i];
        assert(check(chk));
    }
    scanf("%d%d",&n,&Q);
    scanf("%s",s+1);
    T.build(1,n,1);
    while(Q--) {
        int op,l,r;
        scanf("%d%d%d",&op,&l,&r);
        if(op==1) T.modify(1,n,1,l,r);
        else {
            matrix chk=T.query(1,n,1,l,r);
            puts(check(chk)?"Yes":"No");
        }
    }
    return 0;
}
/*
g++ C.cpp -o C -std=c++14 -Wall -Wextra -Wshadow -fsanitize=address,undefined
*/