#include "bits/stdc++.h"

using namespace std;

constexpr int mod = 998244353;

int normalize(int x) {
    if (x >= mod) {
        x -= mod;
    }
    if (x < 0) {
        x += mod;
    }
    return x;
}

template<typename T>
T power(T a, int n) {
    T res = 1;
    for (; n; n /= 2, a *= a) {
        if (n % 2) {
            res *= a;
        }
    }
    return res;
}

class Mint {
public:
    int x;

    Mint(int x = 0) : x(normalize(x)) {}
    Mint(long long x) : x(normalize(x % mod)) {}

    int val() const {
        return x;
    }

    Mint operator-() const {
        return Mint(normalize(mod - x));
    }

    Mint inv() const {
        return power(*this, mod - 2);
    }

    Mint& operator*=(const Mint& rhs) {
        x = x * 1ll * rhs.x % mod;
        return *this;
    }

    Mint& operator+=(const Mint& rhs) {
        x = normalize(x + rhs.x);
        return *this;
    }

    Mint& operator-=(const Mint& rhs) {
        x = normalize(x - rhs.x);
        return *this;
    }

    Mint& operator/=(const Mint& rhs) {
        return *this *= rhs.inv();
    }

    friend Mint operator*(const Mint& lhs, const Mint& rhs) {
        Mint res = lhs;
        res *= rhs;
        return res;
    }

    friend Mint operator+(const Mint& lhs, const Mint& rhs) {
        Mint res = lhs;
        res += rhs;
        return res;
    }

    friend Mint operator-(const Mint& lhs, const Mint& rhs) {
        Mint res = lhs;
        res -= rhs;
        return res;
    }

    friend Mint operator/(const Mint& lhs, const Mint& rhs) {
        Mint res = lhs;
        res /= rhs;
        return res;
    }
};

using mint = Mint;

vector<mint> fact(1, 1);
vector<mint> inv_fact(1, 1);

void fast(int n) {
    while ((int) fact.size() < n + 1) {
        fact.push_back(fact.back() * (int) fact.size());
    }
    inv_fact.resize(n + 1, 1);
    inv_fact[n] = 1 / fact[n];
    for (int i = n - 1; i >= 2; i--) {
        inv_fact[i] = inv_fact[i + 1] * (i + 1);
    }
}

mint C(int n, int k) {
    if (k < 0 || k > n) {
        return 0;
    }
    while ((int) fact.size() < n + 1) {
        fact.push_back(fact.back() * (int) fact.size());
        inv_fact.push_back(fact.back().inv());
    }
    return fact[n] * inv_fact[k] * inv_fact[n - k];
}


mt19937 gen(time(0));
using T = array<array<mint, 2>, 2>;
T mat[3];
T matr[3];

T mul(T a, T b) {
    T res;
    for (int i = 0; i < 2; i++) {
        for (int j = 0; j < 2; j++) {
            res[i][j] = 0;
            for (int k = 0; k < 2; k++) {
                res[i][j] += a[i][k] * b[k][j];
            }
        }
    }
    return res;
}

const int N = 5e5 + 22;
T tree[4 * N][3];
int d[4 * N];
string s;
T E;

void build(int v, int l, int r) {
    if (l + 1 == r) {
        for (int i : {0, 1, 2}) {
            int j = i + (s[l] - '0');
            j %= 3;
            if (l % 2 == 0) {
                tree[v][i] = mat[j];
            } else {
                tree[v][i] = matr[j];
            }
        }
        return;
    }
    int m = (l + r) / 2;
    build(v * 2 + 1, l, m);
    build(v * 2 + 2, m, r);
    for (int i : {0, 1, 2}) {
        tree[v][i] = mul(tree[v * 2 + 1][i], tree[v * 2 + 2][i]);
    }
}

void push(int v, int l, int r) {
    d[v] %= 3;
    if (d[v] == 1) {
        swap(tree[v][0], tree[v][1]);
        swap(tree[v][1], tree[v][2]);
    } else if (d[v] == 2) {
        swap(tree[v][0], tree[v][2]);
        swap(tree[v][1], tree[v][2]);
    }
    if (l + 1 < r) {
        d[v * 2 + 1] += d[v];
        d[v * 2 + 2] += d[v];
    }
    d[v] = 0;
}

void update(int v, int l, int r, int l2, int r2) {
    push(v, l, r);
    if (l2 >= r || l >= r2) {
        return;
    }
    if (l2 <= l && r <= r2) {
        d[v]++;
        push(v, l, r);
        return;
    }
    int m = (l + r) / 2;
    update(v * 2 + 1, l, m, l2, r2);
    update(v * 2 + 2, m, r, l2, r2);
    for (int i : {0, 1, 2}) {
        tree[v][i] = mul(tree[v * 2 + 1][i], tree[v * 2 + 2][i]);
    }
}

T get(int v, int l, int r, int l2, int r2) {
    push(v, l, r);
    if (l2 >= r || l >= r2) {
        return E;
    }
    if (l2 <= l && r <= r2) {
        return tree[v][0];
    }
    int m = (l + r) / 2;
    return mul(get(v * 2 + 1, l, m, l2, r2), get(v * 2 + 2, m, r, l2, r2));
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    E[0][0] = E[1][1] = 1;
    E[0][1] = E[1][0] = 0;
    for (int i = 0; i < 3; i++) {
        while (1) {
            for (int x : {0, 1}) {
                for (int y : {0, 1}) {
                    int z = gen() % mod;
                    mat[i][x][y] = mint(z);
                }
            }
            mint det = mat[i][0][0] * mat[i][1][1] - mat[i][0][1] * mat[i][1][0];
            if (det.x == 0) {
                continue;
            }
            matr[i] = mat[i];
            swap(matr[i][0][0], matr[i][1][1]);
            for (int x : {0, 1}) {
                for (int y : {0, 1}) {
                    if (x != y) {
                        matr[i][x][y] *= -1;
                    }
                    matr[i][x][y] /= det;
                }
            }
            break;
        }
    }
    int n, q;
    cin >> n >> q;
    cin >> s;
    build(0, 0, n);
    while (q--) {
        int t, l, r;
        cin >> t >> l >> r;
        l--, r--;
        if (t == 1) {
            update(0, 0, n, l, r + 1);
        } else {
            T res = get(0, 0, n, l, r + 1);
            if (res[0][0].x == 1 && res[1][1].x == 1 && res[0][1].x == 0 && res[1][0].x == 0) {
                cout << "Yes\n";
            } else {
                cout << "No\n";
            }
        }
    }
}