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

#define MAXN 500005
typedef long long ll;
const ll Ha = 998244353;


ll ksm(ll x, int k) {
    ll ret = 1;
    for (; k; k>>=1, x=x*x%Ha)
        if (k&1) ret = ret*x %Ha;
    if (ret < 0) ret = ret+Ha;
    return ret;
}

struct Matrix {
    int dim;
    ll a[2][2];

    Matrix(): dim(2) {};
    Matrix(int v): dim(2) {
        memset(a, 0, sizeof(a));
        for (int i=0; i<dim; i++) a[i][i] = v;
    }
    
    ll* operator[](int x) {return a[x];}
    const ll* operator[](int x) const {return a[x];}

    Matrix operator*(const Matrix &b) {
        Matrix ret(0);
        for (int i=0; i<dim; i++)
            for (int j=0; j<dim; j++) {
                for (int k=0; k<dim; k++)
                    ret[i][j] = (ret[i][j] + a[i][k]*b[k][j] %Ha);
                ret[i][j] = ret[i][j] %Ha;
            }
        return ret;
    }

    bool operator==(const Matrix &b) const {
        if (dim != b.dim) return false;
        for (int i=0; i<dim; i++)
            for (int j=0; j<dim; j++)
                if (a[i][j] != b[i][j]) return false;
        return true;
    }


    friend ostream& operator<<(ostream &fout, const Matrix &X) {
        for (const auto &r: X.a) {
            for (const auto &x: r) fout <<x <<" ";
            fout <<"\n";
        }
        return fout;
    }
};

const Matrix I(1);
Matrix A[3][2];

void gen_A()
{
    for (int t=0; t<3; t++) {
        Matrix &M = A[t][0];
        Matrix &iM = A[t][1];
        M = iM = Matrix(1);
        int vvv[3] = {2, 3, 5};
        for (int i=0; i<2; i++)
            for (int j=0; j<2; j++)
                M.a[i][j] = rand()%Ha;
        
        ll a(M.a[0][0]), b(M.a[0][1]), c(M.a[1][0]), d(M.a[1][1]);
        ll det = a*d%Ha - b*c%Ha;
        ll idet = ksm(det, Ha-2);
        iM.a[0][0] = d * idet %Ha;
        iM.a[1][0] = (-c+Ha) * idet %Ha;
        iM.a[0][1] = (-b+Ha) * idet %Ha;
        iM.a[1][1] = a * idet %Ha;

    }
}


struct Node {
    int l, r;
    Matrix v[3];
    int tag;

    Node(): tag(0) {}
};

#define LX (x<<1)
#define RX ((x<<1)|1)
struct Segment_tree {
    Node a[MAXN*8];


    void merge(Node &x, Node &lx, Node &rx) {
        for (int i=0; i<3; i++) x.v[i] = lx.v[i] * rx.v[i];
    }

    void do_cycle(int x, int t) {
        static Matrix tmp[3];
        for (int i=0; i<3; i++) tmp[i] = a[x].v[(i+t)%3];
        for (int i=0; i<3; i++) a[x].v[i] = tmp[i];
    }

    void add_tag(int x, int t) {
        do_cycle(x, t);
        a[x].tag+=t;
    }

    void push_down(int x) {
        if (a[x].tag == 0 || a[x].l == a[x].r) return;

        add_tag(LX, a[x].tag);
        add_tag(RX, a[x].tag);
        a[x].tag = 0;
    }


    void build(int x, int l, int r, const char *s) {
        a[x].l = l;
        a[x].r = r;
        a[x].tag = 0;
        if (l == r) {
            for (int i=0; i<3; i++) a[x].v[i] = A[(s[l]-'0'+i)%3][l&1];
            return;
        }
        int m = (l+r)/2;
        build(LX, l, m, s);
        build(RX, m+1, r, s);
        merge(a[x], a[LX], a[RX]);
    }

    void modify(int x, int L, int R) {
        if (L <= a[x].l && a[x].r <= R) {
            add_tag(x, 1);
            return;
        }

        push_down(x);

        if (a[LX].r >= L) modify(LX, L, R);
        if (a[RX].l <= R) modify(RX, L, R);

        merge(a[x], a[LX], a[RX]);
    }


    Node query(int x, int L, int R) {
        if (L <= a[x].l && a[x].r <= R) {
            return a[x];
        }

        push_down(x);

        Node ret, lx, rx;
        for (int i=0; i<3; i++) lx.v[i] = rx.v[i] = I;

        if (a[LX].r >= L) lx = query(LX, L, R);
        if (a[RX].l <= R) rx = query(RX, L, R);
        merge(ret, lx, rx);

        return ret;
    }

};


Segment_tree segment_tree;


void solve()
{
    int n, q;
    string s;
    cin >>n >>q >>s;
    segment_tree.build(1, 1, n, s.c_str()-1);

    while (q--) {
        int op, l, r;
        cin >>op >>l >>r;
        if (op == 1) {
            segment_tree.modify(1, l, r);
        }
        else {
            Node tmp = segment_tree.query(1, l, r);
            //cout <<tmp.v[0] <<"\n";
            if (tmp.v[0] == I) cout <<"Yes\n";
            else cout <<"No\n";
        }
    }
}




int main()
{
    std::ios::sync_with_stdio(false);
    std::cin.tie(0);
    gen_A();
    solve();
}


/*


10 3
2121100100
1 5 10
1 2 10
2 4 9


20 3
22111120212100222200
1 3 13
1 4 15
2 11 16



*/