#pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
inline int read() {
    char ch = getchar();
    int x = 0;
    while (ch < '0' || ch > '9') ch = getchar();
    while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
    return x;
}

namespace Solve {
    const int M = 5e5 + 10, mod = 998244353;
    inline int qpow(int b, int p) {
        int ret = 1;
        for (; p; p >>= 1) {
            if (p & 1) ret = 1ll * ret * b % mod;
            b = 1ll * b * b % mod;
        }
        return ret;
    }

    int n, q, a[M];
    
    typedef array<array<int, 2>, 2> matrix;
    inline matrix operator * (matrix A, matrix B) {
        matrix C;
        C[0][0] = (1ll * A[0][0] * B[0][0] + 1ll * A[0][1] * B[1][0]) % mod;
        C[0][1] = (1ll * A[0][0] * B[0][1] + 1ll * A[0][1] * B[1][1]) % mod;
        C[1][0] = (1ll * A[1][0] * B[0][0] + 1ll * A[1][1] * B[1][0]) % mod;
        C[1][1] = (1ll * A[1][0] * B[0][1] + 1ll * A[1][1] * B[1][1]) % mod;
        return C;
    }
    inline matrix operator * (matrix A, int b) {
        A[0][0] = 1ll * A[0][0] * b % mod;
        A[0][1] = 1ll * A[0][1] * b % mod;
        A[1][0] = 1ll * A[1][0] * b % mod;
        A[1][1] = 1ll * A[1][1] * b % mod;
        return A;
    }
    inline matrix inv(matrix A) {
        int det = ((1ll * A[0][0] * A[1][1] - 1ll * A[1][0] * A[0][1]) % mod + mod) % mod;
        swap(A[0][0], A[1][1]);
        A[0][1] = (mod - A[0][1]), A[1][0] = (mod - A[1][0]);
        return A * qpow(det, mod - 2);
    }

    const matrix A[3] = {{146236431, 136351253, 123423431, 61095632}, {19518913, 952298967, 28918964, 13902481}, {192095908, 8045343, 189873598, 329874397}};
    const matrix iA[3] = {inv(A[0]), inv(A[1]), inv(A[2])}, E = {1, 0, 0, 1};
    

    int add[M << 2];
    matrix prod[3][M << 2];
    inline void pushup(int k) {
        for (int i : {0, 1, 2})
            prod[i][k] = prod[i][k << 1] * prod[i][k << 1 | 1];
    }
    inline void tag(int k, int x) {
        (add[k] += x) %= 3;
        swap(prod[0][k], prod[x][k]), swap(prod[1][k], prod[2][k]);
    }
    inline void pushdown(int k) {
        if (add[k])
            tag(k << 1, add[k]), tag(k << 1 | 1, add[k]), add[k] = 0;
    }
    inline void build(int k = 1, int l = 1, int r = n) {
        if (l == r) {
            for (int i : {0, 1, 2})
                prod[i][k] = (l & 1) ? A[(a[l] + i) % 3] : iA[(a[l] + i) % 3];
            return ;
        }
        int mid = (l + r) >> 1;
        build(k << 1, l, mid), build(k << 1 | 1, mid + 1, r);
        pushup(k);
    }
    inline void upd(int L, int R, int k = 1, int l = 1, int r = n) {
        if (L <= l && r <= R) return tag(k, 1);
        pushdown(k);
        int mid = (l + r) >> 1;
        if (L <= mid) upd(L, R, k << 1, l, mid);
        if (R > mid)  upd(L, R, k << 1 | 1, mid + 1, r);
        pushup(k);
    }
    inline matrix ask(int L, int R, int k = 1, int l = 1, int r = n) {
        if (L <= l && r <= R) return prod[0][k];
        pushdown(k);
        int mid = (l + r) >> 1;
        if (R <= mid) return ask(L, R, k << 1, l, mid);
        if (L > mid)  return ask(L, R, k << 1 | 1, mid + 1, r);
        return ask(L, R, k << 1, l, mid) * ask(L, R, k << 1 | 1, mid + 1, r);
    }

    void mian() {
        n = read(), q = read();
        for (int i = 1; i <= n; i++) scanf("%1d", &a[i]);
        build();

        for (int tp, l, r; q; q--) {
            tp = read(), l = read(), r = read();
            if (tp == 1) upd(l, r);
            else printf(ask(l, r) == E ? "Yes\n" : "No\n");
        }
        return ;
    }
}

int main() {
    Solve::mian();
    return 0;
}