#include <bits/stdc++.h>

using namespace std;
#define ll long long
#define pii pair<int, int>
#define ld long double
#define all(a) (a).begin(), (a).end()


const int MOD = 998244353;

int add(int a, int b) {
    return a + b >= MOD ? a + b - MOD : a + b;
}

int sub(int a, int b) {
    return a >= b ? a - b : a + MOD - b;
}

int mul(int a, int b) {
    return (1ll * a * b) % MOD;
}

int pw(int x, int n) {
    int res = 1;
    while (n) {
        if (n % 2 == 0) {
            x = mul(x, x);
            n /= 2;
        } else {
            res = mul(res, x);
            n--;
        }
    }
    return res;
}

const int C = 3;

struct Matrix {
    int vals[C][C];
    Matrix() {}
};

Matrix operator*(const Matrix& first, const Matrix& second) {
    Matrix res;
    for (int i = 0; i < C; ++i) {
        fill(res.vals[i], res.vals[i] + C, 0);
    }
    for (int i = 0; i < C; ++i) {
        for (int j = 0; j < C; ++j) {
            for (int k = 0; k < C; ++k) {
                res.vals[i][k] = add(res.vals[i][k], mul(first.vals[i][j], second.vals[j][k]));
            }
        }
    }
    return res;
}

bool operator==(const Matrix& first, const Matrix& second) {
    for (int i = 0; i < C; ++i) {
        for (int j = 0; j < C; ++j) {
            if (first.vals[i][j] != second.vals[i][j])
                return false;
        }
    }
    return true;
}


Matrix gen_rand_matrix() {
    Matrix res;
    for (int i = 0; i < C; ++i) {
        for (int j = 0; j < C; ++j) {
            res.vals[i][j] = (rand() * 1ll * RAND_MAX + rand()) % MOD;
        }
    }
    return res;
}

Matrix gen_rev_matrix(Matrix X) {
    vector<vector<int>> res(C, vector<int>(2 * C));
    for (int i = 0; i < C; ++i) {
        for (int j = 0; j < C; ++j)
            res[i][j] = X.vals[i][j];
    }
    for (int i = 0; i < C; ++i) {
        res[i][C + i] = 1;
    }
    for (int i = 0; i < C; ++i) {
        int id = i;
        while (res[id][i] == 0)
            ++id;
        swap(res[id], res[i]);
        int coeff = pw(res[i][i], MOD - 2);
        for (int j = 0; j < 2 * C; ++j)
            res[i][j] = mul(res[i][j], coeff);
        for (int l = i + 1; l < C; ++l) {
            int coeff = res[l][i];
            for (int j = 0; j < 2 * C; ++j) {
                res[l][j] = sub(res[l][j], mul(res[i][j], coeff));
            }
        }
    }
    for (int i = C - 1; i >= 0; --i) {
        for (int l = i + 1; l < C; ++l) {
            int coeff = res[i][l];
            for (int j = 0; j < 2 * C; ++j)
                res[i][j] = sub(res[i][j], mul(res[l][j], coeff));
        }
    }
    Matrix ans;
    for (int i = 0; i < C; ++i) {
        for (int j = 0; j < C; ++j) {
            ans.vals[i][j] = res[i][C + j];
        }
    }
    return ans;
}


Matrix base_matrices[3];

Matrix vals[(1 << 20) + 228][3];
int mod[(1 << 20) + 228];

void build(int v, int left, int right, const string& s) {
    mod[v] = 0;
    if (left + 1 == right) {
        int c = (s[left] - '0');
        for (int i = 0; i < 3; ++i) {
            vals[v][i] = base_matrices[(c + i) % 3];
        }
        return;
    }
    int mid = (left + right) / 2;
    build(2 * v + 1, left, mid, s);
    build(2 * v + 2, mid, right, s);
    for (int i = 0; i < 3; ++i)
        vals[v][i] = vals[2 * v + 1][i] * vals[2 * v + 2][i];
}

void push(int v, int left, int right) {
    if (mod[v] == 0)
        return;
    rotate(vals[v], vals[v] + mod[v], vals[v] + 3);
    if (left + 1 != right) {
        mod[2 * v + 1] = (mod[2 * v + 1] + mod[v]) % 3;
        mod[2 * v + 2] = (mod[2 * v + 2] + mod[v]) % 3;
    }
    mod[v] = 0;
}

Matrix get(int v, int left, int right, int x, int y) {
    push(v, left, right);
    if (x <= left && right <= y)
        return vals[v][0];
    int mid = (left + right) / 2;
    if (y <= mid)
        return get(2 * v + 1, left, mid, x, y);
    if (x >= mid)
        return get(2 * v + 2, mid, right, x, y);
    return get(2 * v + 1, left, mid, x, y) * get(2 * v + 2, mid, right, x, y);
}

void upd(int v, int left, int right, int x, int y) {
    push(v, left, right);
    if (y <= left || right <= x) {
        return;
    }
    if (x <= left && right <= y) {
        mod[v] = (mod[v] + 1) % 3;
        push(v, left, right);
        return;
    }
    int mid = (left + right) / 2;
    upd(2 * v + 1, left, mid, x, y);
    upd(2 * v + 2, mid, right, x, y);
    for (int i = 0; i < 3; ++i)
        vals[v][i] = vals[2 * v + 1][i] * vals[2 * v + 2][i];
}


signed main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    Matrix E;
    for (int i = 0; i < C; ++i) {
        for (int j = 0; j < C; ++j)
            E.vals[i][j] = 0;
        E.vals[i][i] = 1;
    }
    for (int i = 0; i < 3; ++i) {
        Matrix A = gen_rand_matrix();
        Matrix B = gen_rev_matrix(A);
        Matrix mid = E;
        for (int i = 0; i < C; ++i) {
            if (rand() % 2)
                mid.vals[i][i] = MOD - 1;
        }
        base_matrices[i] = A * mid * B;
    }

    int n, q;
    cin >> n >> q;
    string s;
    cin >> s;
    build(0, 0, n, s);
    while (q--) {
        int t, l, r;
        cin >> t >> l >> r;
        if (t == 1) {
            upd(0, 0, n, l - 1, r);
        } else {
            Matrix T = get(0, 0, n, l - 1, r);
            if (E == T)
                cout << "Yes\n";
            else
                cout << "No\n";
        }
    }
    return 0;
}