#include <bits/stdc++.h>

using i64 = long long;

template <typename T>
constexpr T power(T a, i64 b) {
    T c{1};
    while (b) {
        if (b % 2) {
            c *= a;
        }
        a *= a;
        b /= 2;
    }
    return c;
}

template <int P>
struct MInt {
    int x;
    constexpr MInt() : x{} {}
    constexpr MInt(i64 x_) : x{up(x_ % getMod())} {}

    static int Mod;
    constexpr static int getMod() {
        return P > 0 ? P : Mod;
    }
    constexpr static void setMod(int Mod_) {
        Mod = Mod_;
    }

    constexpr int up(int x) const {
        if (x < 0) {
            x += getMod();
        }
        return x;
    }
    constexpr int down(int x) const {
        if (x >= getMod()) {
            x -= getMod();
        }
        return x;
    }
    constexpr int norm(int x) const {
        return up(down(x));
    }

    constexpr int val() const {
        return x;
    }
    explicit constexpr operator int() const {
        return x;
    }
    constexpr MInt operator-() const {
        MInt res;
        res.x = norm(getMod() - x);
        return res;
    }
    constexpr MInt inv() const {
        assert(x != 0);
        return power(*this, getMod() - 2);
    }
    constexpr MInt &operator+=(MInt rhs) {
        x = down(x + rhs.x);
        return *this;
    }
    constexpr MInt &operator-=(MInt rhs) {
        x = up(x - rhs.x);
        return *this;
    }
    constexpr MInt &operator*=(MInt rhs) {
        x = 1ll * x * rhs.x % getMod();
        return *this;
    }
    constexpr MInt &operator/=(MInt rhs) {
        return *this *= rhs.inv();
    }
    friend constexpr MInt operator+(MInt lhs, MInt rhs) {
        return lhs += rhs;
    }
    friend constexpr MInt operator-(MInt lhs, MInt rhs) {
        return lhs -= rhs;
    }
    friend constexpr MInt operator*(MInt lhs, MInt rhs) {
        return lhs *= rhs;
    }
    friend constexpr MInt operator/(MInt lhs, MInt rhs) {
        return lhs /= rhs;
    }
    friend constexpr bool operator==(MInt lhs, MInt rhs) {
        return lhs.val() == rhs.val();
    }
    friend constexpr bool operator!=(MInt lhs, MInt rhs) {
        return lhs.val() != rhs.val();
    }
    friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
        i64 x = 0;
        is >> x;
        a = MInt(x);
        return is;
    }
    friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
        return os << a.val();
    }
};

template <int P>
int MInt<P>::Mod = P;
template <>
int MInt<0>::Mod = 998244353;

template <int V, int P>
constexpr MInt<P> CInv = MInt<P>(V).inv();

constexpr int P = 1000000007;
using Z = MInt<P>;

template <typename Info, typename Tag>
struct LazySegmentTree {
    int n;
    std::vector<Info> s;
    std::vector<Tag> t;

    LazySegmentTree() = default;
    LazySegmentTree(int n_, const Info &v = Info{}) {
        init(n_, v);
    }
    template <typename T>
    LazySegmentTree(const std::vector<T> &v) {
        init(v);
    }
    void init(int n_, const Info &v = Info{}) {
        init(std::vector<Info>(n_, v));
    }
    template <typename T>
    void init(const std::vector<T> &v) {
        n = int(v.size());
        s.assign(4 << std::__lg(n), Info{});
        t.assign(4 << std::__lg(n), Tag{});
        auto build = [&](auto self, int u, int l, int r) -> void {
            if (r - l == 1) {
                s[u] = v[l];
                return;
            }
            int m = (l + r) / 2;
            self(self, u << 1, l, m);
            self(self, u << 1 | 1, m, r);
            pull(u);
        };
        build(build, 1, 0, n);
    }

    void pull(int u) {
        s[u] = s[u << 1] + s[u << 1 | 1];
    }
    void apply(int u, const Tag &v) {
        s[u].apply(v);
        t[u].apply(v);
    }
    void push(int u) {
        apply(u << 1, t[u]);
        apply(u << 1 | 1, t[u]);
        t[u] = Tag{};
    }

    void modify(int u, int l, int r, int p, const Info &v) {
        if (r - l == 1) {
            s[u] = v;
            return;
        }
        int m = (l + r) / 2;
        push(u);
        if (p < m) {
            modify(u << 1, l, m, p, v);
        } else {
            modify(u << 1 | 1, m, r, p, v);
        }
        pull(u);
    }
    void modify(int p, const Info &v) {
        modify(1, 0, n, p, v);
    }

    Info query(int u, int l, int r, int p) {
        if (r - l == 1) {
            return s[u];
        }
        int m = (l + r) / 2;
        push(u);
        if (p < m) {
            return query(u << 1, l, m, p);
        } else {
            return query(u << 1 | 1, m, r, p);
        }
    }
    Info query(int p) {
        return query(1, 0, n, p);
    }

    Info rangeQuery(int u, int l, int r, int ql, int qr) {
        if (qr <= l || r <= ql) {
            return Info{};
        }
        if (ql <= l && r <= qr) {
            return s[u];
        }
        int m = (l + r) / 2;
        push(u);
        return rangeQuery(u << 1, l, m, ql, qr) + rangeQuery(u << 1 | 1, m, r, ql, qr);
    }
    Info rangeQuery(int ql, int qr) {
        return rangeQuery(1, 0, n, ql, qr);
    }

    void rangeApply(int u, int l, int r, int ql, int qr, const Tag &v) {
        if (qr <= l || r <= ql) {
            return;
        }
        if (ql <= l && r <= qr) {
            apply(u, v);
            return;
        }
        int m = (l + r) / 2;
        push(u);
        rangeApply(u << 1, l, m, ql, qr, v);
        rangeApply(u << 1 | 1, m, r, ql, qr, v);
        pull(u);
    }
    void rangeApply(int ql, int qr, const Tag &v) {
        rangeApply(1, 0, n, ql, qr, v);
    }
};

constexpr int N = 2;
using Matrix = std::array<std::array<Z, N>, N>;

Matrix operator*(const Matrix &a, const Matrix &b) {
    Matrix c;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            for (int k = 0; k < N; ++k) {
                c[i][k] += a[i][j] * b[j][k];
            }
        }
    }
    return c;
}

struct Tag {
    int v = 0;
    void apply(const Tag &b) {
        v = (v + b.v) % 3;
    }
};

struct Info {
    std::array<Matrix, 3> f;
    Info() {
        for (int i = 0; i < 3; ++i) {
            for (int j = 0; j < N; ++j) {
                f[i][j][j] = 1;
            }
        }
    }
    Info(const std::array<Matrix, 3> &f_) : f{f_} {}
    void apply(const Tag &b) {
        f = {f[b.v], f[(b.v + 1) % 3], f[(b.v + 2) % 3]};
    }
};
Info operator+(const Info &a, const Info &b) {
    return Info{{a.f[0] * b.f[0], a.f[1] * b.f[1], a.f[2] * b.f[2]}};
}

std::mt19937 rnd(std::random_device{}());

std::array<Matrix, 2> get() {
    Matrix a;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            a[i][j] = rnd();
        }
    }
    std::array<std::array<Z, 2 * N>, N> s;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            s[i][j] = a[i][j];
        }
        s[i][i + N] = 1;
    }
    for (int i = 0; i < N; ++i) {
        int p = i;
        while (p < N && s[p][i] == 0) {
            ++p;
        }
        assert(p < N);
        std::swap(s[i], s[p]);
        for (int j = 0; j < N; ++j) {
            if (j == i) {
                continue;
            }
            Z coef = s[j][i] / s[i][i];
            for (int k = 0; k < 2 * N; ++k) {
                s[j][k] -= s[i][k] * coef;
            }
        }
    }
    Matrix b;
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            b[i][j] = s[i][j + N] / s[i][i];
        }
    }
    return {a, b};
}

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

int main() {
    std::cin.tie(nullptr)->sync_with_stdio(false);

    std::array<Matrix, 2> T[3];

    for (auto &x : T) {
        x = get();
    }

    int n, q;
    std::cin >> n >> q;

    std::string s;
    std::cin >> s;

    LazySegmentTree<Info, Tag> seg(n);
    for (int i = 0; i < n; ++i) {
        int v = s[i] - '0';
        seg.modify(i, Info{{T[v][i % 2], T[(v + 1) % 3][i % 2], T[(v + 2) % 3][i % 2]}});
    }

    while (q--) {
        int op, l, r;
        std::cin >> op >> l >> r;
        --l;
        if (op == 1) {
            seg.rangeApply(l, r, Tag{1});
        }
        if (op == 2) {
            if (isone(seg.rangeQuery(l, r).f[0])) {
                std::cout << "Yes\n";
            } else {
                std::cout << "No\n";
            }
        }
    }

    return 0;
}