#include <bits/stdc++.h>

using namespace std;

mt19937 Rand(time(0));
inline int Rnd(int l, int r) {return (Rand() % (r - l + 1) + (r - l + 1)) % (r - l + 1); }
const int MOD = 1e9 + 7;
inline int Plus(int a, int b) {return a + b >= MOD ? a + b - MOD : a + b; }
inline int Minus(int a, int b) {return a - b < 0 ? a - b + MOD : a - b; }

struct matrix {
    int A[2][2] = {{0, 0}, {0, 0}};
    matrix(int a, int b, int c, int d) {
        A[0][0] = a, A[0][1] = b, A[1][0] = c, A[1][1] = d;
    }
    matrix() {}
};
matrix operator * (const matrix &lhs, const matrix &rhs) {
    matrix r;
    r.A[0][0] = Plus(1ll * lhs.A[0][0] * rhs.A[0][0] % MOD, 1ll * lhs.A[0][1] * rhs.A[1][0] % MOD);
    r.A[0][1] = Plus(1ll * lhs.A[0][0] * rhs.A[0][1] % MOD, 1ll * lhs.A[0][1] * rhs.A[1][1] % MOD);
    r.A[1][0] = Plus(1ll * lhs.A[1][0] * rhs.A[0][0] % MOD, 1ll * lhs.A[1][1] * rhs.A[1][0] % MOD);
    r.A[1][1] = Plus(1ll * lhs.A[1][0] * rhs.A[0][1] % MOD, 1ll * lhs.A[1][1] * rhs.A[1][1] % MOD);
    return r;
}
bool operator == (const matrix &lhs, const matrix &rhs) {
    return lhs.A[0][0] == rhs.A[0][0] && lhs.A[0][1] == rhs.A[0][1] && lhs.A[1][0] == rhs.A[1][0] && lhs.A[1][1] == rhs.A[1][1];
}
bool operator != (const matrix &lhs, const matrix &rhs) {return !(lhs == rhs); }
inline matrix I() {return matrix(1, 0, 0, 1); }
inline matrix ksm(matrix A, int b) {
    matrix r = I();
    while(b) {
        if(b & 1) r = r * A;
        b >>= 1, A = A * A;
    }
    return r;
}

matrix A[2][3] = {
    {matrix(0, 1, 1, 1), matrix(1, 2, 0, 1), matrix(1, 0, 3, 1)},
    {matrix(-1, 1, 1, 0), matrix(1, -2, 0, 1), matrix(1, 0, -3, 1)}
};

const int N = 5e5 + 10;
string S; int s[N];

namespace SegmentTree {
#define lc (u << 1)
#define rc (u << 1 | 1)
    matrix C[N << 2][3][8]; int c[N << 2][3], tag[N << 2];
    inline void Tag(int u, int v) {
        if(v == 0) return;
        tag[u] = (tag[u] + v) % 3;
        if(v == 1) {
            for(int j = 0; j < 8; j ++) swap(C[u][0][j], C[u][1][j]), swap(C[u][1][j], C[u][2][j]);
            swap(c[u][0], c[u][1]), swap(c[u][1], c[u][2]);
        } else {
            for(int j = 0; j < 8; j ++) swap(C[u][1][j], C[u][2][j]), swap(C[u][0][j], C[u][1][j]);
            swap(c[u][1], c[u][2]), swap(c[u][0], c[u][1]);
        }
    }
    inline void maintain(int u) {
        c[u][0] = c[lc][0] ^ c[rc][0], c[u][1] = c[lc][1] ^ c[rc][1], c[u][2] = c[lc][2] ^ c[rc][2];
        for(int i = 0; i < 3; i ++) for(int mask = 0; mask < 8; mask ++) {
            C[u][i][mask] = C[lc][i][mask] * C[rc][i][mask ^ c[lc][i]];
        }
    }
    inline void pushdown(int u) { if(!tag[u]) return;
        Tag(lc, tag[u]), Tag(rc, tag[u]), tag[u] = 0;
    }
    void Build(int u, int l, int r) { tag[u] = 0;
        if(l != r) {
            int mid = (l + r) >> 1;
            Build(lc, l, mid), Build(rc, mid + 1, r);
            maintain(u);
        } else {
            for(int i = 0; i < 3; i ++) c[u][i] = 1 << (s[l] + i) % 3;
            for(int mask = 0; mask < 8; mask ++) for(int i = 0; i < 3; i ++) {
                int x = (s[l] + i) % 3;
                C[u][i][mask] = A[mask >> x & 1][x];
            }
        }
    }
    void Modify(int u, int l, int r, int L, int R) {
        if(l >= L && r <= R) {Tag(u, 1); return; }
        int mid = (l + r) >> 1; pushdown(u);
        if(mid >= L) Modify(lc, l, mid, L, R);
        if(mid < R) Modify(rc, mid + 1, r, L, R);
        maintain(u);
    }
    pair<int, matrix> Ask(int u, int l, int r, int L, int R, int mask = 0) {
        if(l >= L && r <= R) {return {mask ^ c[u][0], C[u][0][mask]}; }
        int mid = (l + r) >> 1; pushdown(u);
        if(mid >= R) return Ask(lc, l, mid, L, R, mask);
        if(mid < L) return Ask(rc, mid + 1, r, L, R, mask);
        auto pr = Ask(lc, l, mid, L, R, mask); auto ans = Ask(rc, mid + 1, r, L, R, pr.first);
        ans.second = pr.second * ans.second; return ans;
    }
#undef lc
#undef rc
}

inline matrix gen() {return matrix(Rnd(0, MOD - 1), Rnd(0, MOD - 1), Rnd(0, MOD - 1), Rnd(0, MOD - 1)); }

int main() {
    ios::sync_with_stdio(false), cin.tie(0);
    for(int i = 0; i < 3; i ++) {
        while(true) {
            matrix T = gen();
            if(ksm(T, MOD - 1) == I()) {A[0][i] = T, A[1][i] = ksm(T, MOD - 2); break; }
        }
    } 

    int n, q; cin >> n >> q;
    cin >> S; S = "$" + S; for(int i = 1; i <= n; i ++) s[i] = S[i] - '0';
    SegmentTree::Build(1, 1, n);

    while(q --) {
        int op, l, r; cin >> op >> l >> r;
        // if(op == 1) {
        //     for(int i = l; i <= r; i ++) s[i] = (s[i] + 1) % 3;
        //     SegmentTree::Build(1, 1, n);
        // }
        if(op == 1) SegmentTree::Modify(1, 1, n, l, r);
        else {
            auto pr = SegmentTree::Ask(1, 1, n, l, r);
            cout << (pr.first == 0 && pr.second == I() ? "Yes" : "No") << '\n';
        }
    }

    return 0;
}