#include <bits/stdc++.h>

#ifdef LOCAL
#include <debug.h>
#else
#define debug(...)
#define debug_arr(...)
#define debug_endl(...)
#endif

using u32 = unsigned int;

std::mt19937 rng(std::chrono::steady_clock::now().time_since_epoch().count());

template<int P>
struct MInt {
	static int m;
	static constexpr int mod() {
		return P ? P : m;
	}
	static constexpr void set(int m) {
		MInt::m = m;
	}

	int x;

	constexpr MInt(): x(0) {}
	template<class T>
	constexpr MInt(const T &x): x(int(x % mod() + mod()) % mod()) {}

	template<class T>
	explicit constexpr operator T() const {
		return T(x);
	}

	template<class T>
	constexpr MInt pow(T b) const {
		MInt res = 1;
		for (MInt a = *this; b; a *= a, b >>= 1) {
			if (b & 1) {
				res *= a;
			}
		}
		return res;
	}

	constexpr MInt inv() const {
		assert(x);
		return pow(mod() - 2);
	}

	constexpr MInt &operator+=(const MInt &b) {
		x += b.x;
		if (x >= mod()) {
			x -= mod();
		}
		return *this;
	}
	constexpr MInt &operator-=(const MInt &b) {
		x -= b.x;
		if (x < 0) {
			x += mod();
		}
		return *this;
	}
	constexpr MInt &operator*=(const MInt &b) {
		x = 1ll * x * b.x % mod();
		return *this;
	}
	constexpr MInt &operator/=(const MInt &b) {
		return *this = *this * b.inv();
	}

	friend constexpr MInt operator+(const MInt &a, const MInt &b) {
		return MInt(a) += b;
	}
	friend constexpr MInt operator-(const MInt &a, const MInt &b) {
		return MInt(a) -= b;
	}
	friend constexpr MInt operator*(const MInt &a, const MInt &b) {
		return MInt(a) *= b;
	}
	friend constexpr MInt operator/(const MInt &a, const MInt &b) {
		return MInt(a) /= b;
	}

	constexpr MInt &operator++() {
		return *this += 1;
	}
	constexpr MInt &operator--() {
		return *this -= 1;
	}

	constexpr MInt operator++(int) {
		MInt res = *this;
		++*this;
		return res;
	}
	constexpr MInt operator--(int) {
		MInt res = *this;
		--*this;
		return res;
	}

	constexpr MInt operator+() const {
		return *this;
	}
	constexpr MInt operator-() const {
		return 0 - *this;
	}
	
	friend constexpr bool operator==(const MInt &a, const MInt &b) {
		return int(a) == int(b);
	}
	friend constexpr bool operator!=(const MInt &a, const MInt &b) {
		return int(a) != int(b);
	}

	friend constexpr std::istream &operator>>(std::istream &is, MInt &a) {
		int v;
		is >> v;
		a = v;
		return is;
	}
	friend constexpr std::ostream &operator<<(std::ostream &os, const MInt &a) {
		return os << int(a);
	}
};

template<int P>
int MInt<P>::m = 1;

template<int x, int P>
constexpr MInt<P> cinv = MInt<P>(x).inv();

constexpr int P = 998244353;

using Matrix = std::array<std::array<MInt<P>, 2>, 2>;

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

constexpr Matrix inv(Matrix a) {
	Matrix res = {};
	for (int i = 0; i < 2; i++) {
		res[i][i] = 1;
	}
	for (int i = 0; i < 2; i++) {
		int c = -1;
		for (int j = i; j < 2; j++) {
			if (a[j][i] != 0) {
				c = j;
				break;
			}
		}
		std::swap(a[i], a[c]);
		std::swap(res[i], res[c]);

		for (int j = 0; j < 2; j++) {
			if (i == j) {
				continue;
			}

			MInt<P> x = a[j][i] / a[i][i];
			for (int k = i; k < 2; k++) {
				a[j][k] -= x * a[i][k];
			}
			for (int k = 0; k < 2; k++) {
				res[j][k] -= x * res[i][k];
			}
		}
	}
	for (int i = 0; i < 2; i++) {
		MInt<P> x = a[i][i].inv();
		for (int j = 0; j < 2; j++) {
			res[i][j] *= x;
		}
	}
	return res;
}

template<class Info, class Tag>
struct LazySegmentTree {
	int n;
	std::vector<Info> info;
	std::vector<Tag> tag;

	void pull(int o) {
		info[o] = info[o << 1] + info[o << 1 | 1];
	}

	void apply(int o, const Tag &x) {
		info[o].apply(x);
		tag[o].apply(x);
	}

	void push(int o) {
		apply(o << 1, tag[o]);
		apply(o << 1 | 1, tag[o]);
		tag[o] = {};
	}
	
	LazySegmentTree() {}
	LazySegmentTree(int n) {
		init(n);
	}
	LazySegmentTree(int n, const Info &val) {
		init(n, val);
	}
	LazySegmentTree(const std::vector<Info> &val) {
		init(val);
	}

	void init(int n) {
		this->n = n;
		info.assign(2 * std::bit_ceil<u32>(n), {});
		tag.assign(2 * std::bit_ceil<u32>(n), {});
	}
	void init(int n, const Info &val) {
		init(std::vector(n, val));
	}
	void init(const std::vector<Info> &val) {
		init(val.size());

		auto init = [&](auto &&self, int o, int s, int t) -> void {
			if (s + 1 == t) {
				info[o] = val[s];
				return;
			}

			int mid = std::midpoint(s, t);
			self(self, o << 1, s, mid);
			self(self, o << 1 | 1, mid, t);
			pull(o);
		};

		init(init, 1, 0, n);
	}

	void modify(int i, const Info &x) {
		auto modify = [&](auto &&self, int o, int s, int t) -> void {
			if (s + 1 == t) {
				info[o] = x;
				return;
			}

			int mid = std::midpoint(s, t);
			push(o);
			if (i < mid) {
				self(self, o << 1, s, mid);
			} else {
				self(self, o << 1 | 1, mid, t);
			}
			pull(o);
		};

		modify(modify, 1, 0, n);
	}

	void range_apply(int l, int r, const Tag &x) {
		auto range_apply = [&](auto &&self, int o, int s, int t) -> void {
			if (s >= r || t <= l) {
				return;
			}
			if (l <= s && t <= r) {
				apply(o, x);
				return;
			}

			int mid = std::midpoint(s, t);
			push(o);
			self(self, o << 1, s, mid);
			self(self, o << 1 | 1, mid, t);
			pull(o);
		};

		range_apply(range_apply, 1, 0, n);
	}

	Info range_query(int l, int r) {
		auto range_query = [&](auto &&self, int o, int s, int t) -> Info {
			if (s >= r || t <= l) {
				return {};
			}
			if (l <= s && t <= r) {
				return info[o];
			}

			int mid = std::midpoint(s, t);
			push(o);
			return self(self, o << 1, s, mid) + self(self, o << 1 | 1, mid, t);
		};

		return range_query(range_query, 1, 0, n);
	}
};

struct Tag {
	int add;

	Tag(): add(0) {}
	Tag(int add): add(add) {}

	void apply(const Tag &x) {
		add = (add + x.add) % 3;
	}
};

struct Info {
	std::array<Matrix, 3> mat;

	Info() {
		for (int i = 0; i < 3; i++) {
			mat[i][0] = {1, 0};
			mat[i][1] = {0, 1};
		}
	}
	Info(std::array<Matrix, 3> mat): mat(mat) {}

	void apply(const Tag &x) {
		std::rotate(mat.begin(), mat.begin() + x.add, mat.end());
	}

	friend Info operator+(const Info &a, const Info &b) {
		Info res;
		for (int i = 0; i < 3; i++) {
			res.mat[i] = a.mat[i] * b.mat[i];
		}
		return res;
	}
};

void solve() {
	std::array<Matrix, 6> mat;
	for (int i = 0; i < 3; i++) {
		mat[2 * i][0] = {rng(), rng()};
		mat[2 * i][1] = {rng(), rng()};
		mat[2 * i + 1] = inv(mat[2 * i]);
	}
	Matrix ide;
	ide[0] = {1, 0};
	ide[1] = {0, 1};

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

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

	std::vector<Info> init(n);
	for (int i = 0; i < n; i++) {
		for (int j = 0; j < 3; j++) {
			init[i].mat[j] = mat[2 * ((s[i] - '0' + j) % 3) + i % 2];
		}
	}
	LazySegmentTree<Info, Tag> seg(init);

	while (q--) {
		int op, l, r;
		std::cin >> op >> l >> r;
		l--;

		if (op == 1) {
			seg.range_apply(l, r, 1);
		} else {
			std::cout << (seg.range_query(l, r).mat[0] == ide ? "Yes" : "No") << "\n";
		}
	}
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(nullptr);
	std::cout.setf(std::ios::fixed);
	std::cout.precision(10);

	solve();

	return 0;
}