#include <bits/stdc++.h>

using namespace std;


using i32 = int32_t;
using i64 = long long;

const i32 inf = INT_MAX / 2;
const i64 INF = LLONG_MAX / 2;

struct Info{
	i64 value, mul;

	Info(i64 value = 0) : value(value) {
		mul = 1;
	}

	i64 val() const {
		return value * mul;
	}

	Info operator+(const Info &b) {
		Info ret;
		ret.value = val() + b.val();
		ret.mul = 1;
		return ret;
	}
};

struct Node {
	i32 l, r;
	Info info;
	Node *left, *right;

	Node(i32 p, i64 v = 1) : info(v) {
		l = r = p;
		left = right = nullptr;
	}

	Node(i32 l, i32 r, Node *left, Node *right) 
		: l(l), r(r), left(left), right(right) {
		info = left -> info + right -> info;
	}

};

void maintain(Node *cur) {
	if(cur -> left == nullptr) return;
	cur -> info = cur -> left -> info + cur -> right -> info;
	return;
}

void pushdown(Node *cur) {
	if(cur -> info.mul == 1) return;
	if(cur -> left != nullptr) {
		cur -> left -> info.mul *= cur -> info.mul;
		cur -> right -> info.mul *= cur -> info.mul;
	}
	cur -> info.mul = 1;
	return;
}

Node *build(i32 l, i32 r) {
	if(l == r) return new Node(l);
	i32 mid = (l + r) / 2;
	auto left = build(l, mid) , right = build(mid + 1, r);
	return new Node(l, r, left, right);
}

Info query(i32 l, i32 r, Node *cur) {
	if(cur == nullptr) return Info();
	if(cur -> r < l or cur -> l > r) return Info();
	if(l <= cur -> l and cur -> r <= r) return cur -> info;
	pushdown(cur);
	return query(l, r, cur -> left) + query(l, r, cur -> right);
}

i64 pre(i32 i, Node *cur) {
	return query(-inf, i, cur).val();
}


void update_add(i32 p, i64 x, Node *cur) {
	if(cur == nullptr) return;
	if(p > cur -> r or cur -> l > p) return;
	pushdown(cur);
	if(p == cur -> l and cur -> r == p) {
		cur -> info.value += x;
		return;
	}
	update_add(p, x, cur -> left), update_add(p, x, cur -> right);
	maintain(cur);
	return;
}

void modify_mul(i32 l, i32 r, i64 x, Node *cur) {
	if(cur == nullptr) return;
	if(l > cur -> r or r < cur -> l) return;
	pushdown(cur);
	if(l <=cur -> l and cur -> r <= r) {
		cur -> info.mul *= x;
		return;
	}
	modify_mul(l, r, x, cur -> left), modify_mul(l, r, x, cur  -> right);
	maintain(cur);
	return;
} 


i32 upper(i64 x, Node *cur){
	if(cur -> l == cur -> r) return cur -> l;
	pushdown(cur);
	if(cur -> left -> info.val() < x) {
		x -= cur -> left -> info.val();
		return upper(x, cur -> right);
	} else {
		return upper(x, cur -> left);
	}
}

i32 main() {
	ios::sync_with_stdio(false), cin.tie(nullptr);

	int n, q;
	cin >> n >> q;

	string s;
	cin >> s;
	s = " " + s;

	auto root = build(1, n);

	while(q --) {
		int op;
		cin >> op;
		if(op == 1) {
			i64 l, r;
			cin >> l >> r;
			i64 idxl = upper(l, root);
			i64 idxr = upper(r, root);
			if(idxl != idxr) {
				i64 addl = pre(idxl, root) - l + 1;
				i64 addr = query(idxr, idxr, root).val() - (pre(idxr, root) - r);
				update_add(idxr, addr, root);
				if(idxl + 1 <= idxr - 1) {
					modify_mul(idxl + 1, idxr - 1, 2, root);
				}
				update_add(idxl, addl, root);
			} else {
				update_add(idxl, r - l + 1, root);
			}
		} else {
			i64 x;
			cin >> x;
			cout << s[upper(x, root)] << "\n";
		}
	}
	return 0;
}