// competitive-verifier: PROBLEM
#include <cmath>
#include <cstdint>
#include <numeric>
/// @brief めぐる式二分探索
template <class T, class F>
std::int64_t meguru_binary_search(T ok, T ng, F check) {
while (std::abs(ok - ng) > 1) {
T mid = std::midpoint(ok, ng);
(check(mid) ? ok : ng) = mid;
}
return ok;
}
#include <cassert>
#include <vector>
namespace internal {
// @return same with std::bit::bit_ceil
unsigned int bit_ceil(unsigned int n) {
unsigned int x = 1;
while (x < (unsigned int)(n)) x *= 2;
return x;
}
// @param n `1 <= n`
// @return same with std::bit::countl_zero
int countl_zero(unsigned int n) { return __builtin_clz(n); }
// @param n `1 <= n`
// @return same with std::bit::countr_zero
int countr_zero(unsigned int n) { return __builtin_ctz(n); }
// @param n `1 <= n`
// @return same with std::bit::countr_zero
constexpr int countr_zero_constexpr(unsigned int n) {
int x = 0;
while (!(n & (1 << x))) x++;
return x;
}
} // namespace internal
#include <algorithm>
#include <limits>
#include <utility>
template <class T>
struct Add {
using value_type = T;
static constexpr T id() { return T(); }
static constexpr T op(const T &lhs, const T &rhs) { return lhs + rhs; }
template <class U>
static constexpr U f(T lhs, U rhs) {
return lhs + rhs;
}
};
template <class T>
struct Mul {
using value_type = T;
static constexpr T id() { return T(1); }
static constexpr T op(const T &lhs, const T &rhs) { return lhs * rhs; }
template <class U>
static constexpr U f(T lhs, U rhs) {
return lhs * rhs;
}
};
template <class T>
struct And {
using value_type = T;
static constexpr T id() { return std::numeric_limits<T>::max(); }
static constexpr T op(const T &lhs, const T &rhs) { return lhs & rhs; }
template <class U>
static constexpr U f(T lhs, U rhs) {
return lhs & rhs;
}
};
template <class T>
struct Or {
using value_type = T;
static constexpr T id() { return T(); }
static constexpr T op(const T &lhs, const T &rhs) { return lhs | rhs; }
template <class U>
static constexpr U f(T lhs, U rhs) {
return lhs | rhs;
}
};
template <class T>
struct Xor {
using value_type = T;
static constexpr T id() { return T(); }
static constexpr T op(const T &lhs, const T &rhs) { return lhs ^ rhs; }
template <class U>
static constexpr U f(T lhs, U rhs) {
return lhs ^ rhs;
}
};
template <class T>
struct Min {
using value_type = T;
static constexpr T id() { return std::numeric_limits<T>::max(); }
static constexpr T op(const T &lhs, const T &rhs) { return std::min(lhs, rhs); }
template <class U>
static constexpr U f(T lhs, U rhs) {
return std::min((U)lhs, rhs);
}
};
template <class T>
struct Max {
using value_type = T;
static constexpr T id() { return std::numeric_limits<T>::lowest(); }
static constexpr T op(const T &lhs, const T &rhs) { return std::max(lhs, rhs); }
template <class U>
static constexpr U f(T lhs, U rhs) {
return std::max((U)lhs, rhs);
}
};
template <class T>
struct Gcd {
using value_type = T;
static constexpr T id() { return std::numeric_limits<T>::max(); }
static constexpr T op(const T &lhs, const T &rhs) {
return lhs == Gcd::id() ? rhs : (rhs == Gcd::id() ? lhs : std::gcd(lhs, rhs));
}
};
template <class T>
struct Lcm {
using value_type = T;
static constexpr T id() { return std::numeric_limits<T>::max(); }
static constexpr T op(const T &lhs, const T &rhs) {
return lhs == Lcm::id() ? rhs : (rhs == Lcm::id() ? lhs : std::lcm(lhs, rhs));
}
};
template <class T>
struct Update {
using value_type = T;
static constexpr T id() { return std::numeric_limits<T>::max(); }
static constexpr T op(const T &lhs, const T &rhs) { return lhs == Update::id() ? rhs : lhs; }
template <class U>
static constexpr U f(T lhs, U rhs) {
return lhs == Update::id() ? rhs : lhs;
}
};
template <class T>
struct Affine {
using P = std::pair<T, T>;
using value_type = P;
static constexpr P id() { return P(1, 0); }
static constexpr P op(P lhs, P rhs) {
return {lhs.first * rhs.first, lhs.first * rhs.second + lhs.second};
}
};
template <class M>
struct Rev {
using T = typename M::value_type;
using value_type = T;
static constexpr T id() { return M::id(); }
static constexpr T op(T lhs, T rhs) { return M::op(rhs, lhs); }
};
/**
* @brief 遅延評価セグメント木
* @see https://github.com/atcoder/ac-library/blob/master/atcoder/lazysegtree.hpp
*
* @tparam S モノイド
* @tparam F モノイド
*/
template <class S, class F>
struct lazy_segment_tree {
private:
using T = typename S::value_type;
using U = typename F::value_type;
public:
lazy_segment_tree() : lazy_segment_tree(0) {}
explicit lazy_segment_tree(int n, T e = S::id()) : lazy_segment_tree(std::vector<T>(n, e)) {}
explicit lazy_segment_tree(const std::vector<T> &v) : _n(int(v.size())) {
_size = internal::bit_ceil(_n);
_log = internal::countr_zero(_size);
data = std::vector<T>(2 * _size, S::id());
lazy = std::vector<U>(_size, F::id());
for (int i = 0; i < _n; i++) data[_size + i] = v[i];
for (int i = _size - 1; i >= 1; --i) update(i);
}
void set(int p, T x) {
assert(0 <= p && p < _n);
p += _size;
for (int i = _log; i >= 1; --i) push(p >> i);
data[p] = x;
for (int i = 1; i <= _log; ++i) update(p >> i);
}
T at(int p) { return get(p); }
T get(int p) {
assert(0 <= p && p < _n);
p += _size;
for (int i = _log; i >= 1; --i) push(p >> i);
return data[p];
}
void apply(int p, U f) {
assert(0 <= p && p < _n);
p += _size;
for (int i = _log; i >= 1; --i) push(p >> i);
data[p] = F::f(f, data[p]);
for (int i = 1; i <= _log; ++i) update(p >> i);
}
void apply(int l, int r, U f) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return;
l += _size, r += _size;
for (int i = _log; i >= 1; --i) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
int l2 = l, r2 = r;
while (l < r) {
if (l & 1) all_apply(l++, f);
if (r & 1) all_apply(--r, f);
l >>= 1, r >>= 1;
}
l = l2, r = r2;
for (int i = 1; i <= _log; i++) {
if (((l >> i) << i) != l) update(l >> i);
if (((r >> i) << i) != r) update((r - 1) >> i);
}
}
T prod(int l, int r) {
assert(0 <= l && l <= r && r <= _n);
if (l == r) return S::id();
l += _size, r += _size;
for (int i = _log; i >= 1; --i) {
if (((l >> i) << i) != l) push(l >> i);
if (((r >> i) << i) != r) push((r - 1) >> i);
}
T sml = S::id(), smr = S::id();
while (l < r) {
if (l & 1) sml = S::op(sml, data[l++]);
if (r & 1) smr = S::op(data[--r], smr);
l >>= 1, r >>= 1;
}
return S::op(sml, smr);
}
T all_prod() const { return data[1]; }
template <class G>
int max_right(int l, G g) {
assert(0 <= l && l <= _n);
assert(g(S::id()));
if (l == _n) return _n;
l += _size;
for (int i = _log; i >= 1; i--) push(l >> i);
T sm = S::id();
do {
while (l % 2 == 0) l >>= 1;
if (!g(S::op(sm, data[l]))) {
while (l < _size) {
push(l);
l = (2 * l);
if (g(S::op(sm, data[l]))) {
sm = S::op(sm, data[l]);
l++;
}
}
return l - _size;
}
sm = S::op(sm, data[l]);
l++;
} while ((l & -l) != l);
return _n;
}
private:
int _n, _size, _log;
std::vector<T> data;
std::vector<U> lazy;
void update(int k) { data[k] = S::op(data[2 * k], data[2 * k + 1]); }
void all_apply(int k, U f) {
data[k] = F::f(f, data[k]);
if (k < _size) lazy[k] = F::op(f, lazy[k]);
}
void push(int k) {
all_apply(2 * k, lazy[k]);
all_apply(2 * k + 1, lazy[k]);
lazy[k] = F::id();
}
};
#ifdef ATCODER
#pragma GCC target("sse4.2,avx512f,avx512dq,avx512ifma,avx512cd,avx512bw,avx512vl,bmi2")
#endif
#pragma GCC optimize("Ofast,fast-math,unroll-all-loops")
#include <bits/stdc++.h>
#ifndef ATCODER
#pragma GCC target("sse4.2,avx2,bmi2")
#endif
template <class T, class U>
constexpr bool chmax(T &a, const U &b) {
return a < (T)b ? a = (T)b, true : false;
}
template <class T, class U>
constexpr bool chmin(T &a, const U &b) {
return (T)b < a ? a = (T)b, true : false;
}
constexpr std::int64_t INF = 1000000000000000003;
constexpr int Inf = 1000000003;
constexpr double EPS = 1e-7;
constexpr double PI = 3.14159265358979323846;
#define FOR(i, m, n) for (int i = (m); i < int(n); ++i)
#define FORR(i, m, n) for (int i = (m)-1; i >= int(n); --i)
#define FORL(i, m, n) for (int64_t i = (m); i < int64_t(n); ++i)
#define rep(i, n) FOR (i, 0, n)
#define repn(i, n) FOR (i, 1, n + 1)
#define repr(i, n) FORR (i, n, 0)
#define repnr(i, n) FORR (i, n + 1, 1)
#define all(s) (s).begin(), (s).end()
struct Sonic {
Sonic() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
std::cout << std::fixed << std::setprecision(20);
}
constexpr void operator()() const {}
} sonic;
using namespace std;
using ll = std::int64_t;
using ld = long double;
template <class T, class U>
std::istream &operator>>(std::istream &is, std::pair<T, U> &p) {
return is >> p.first >> p.second;
}
template <class T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
for (T &i : v) is >> i;
return is;
}
template <class T, class U>
std::ostream &operator<<(std::ostream &os, const std::pair<T, U> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <class T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &v) {
for (auto it = v.begin(); it != v.end(); ++it) os << (it == v.begin() ? "" : " ") << *it;
return os;
}
template <class Head, class... Tail>
void co(Head &&head, Tail &&...tail) {
if constexpr (sizeof...(tail) == 0) std::cout << head << '\n';
else std::cout << head << ' ', co(std::forward<Tail>(tail)...);
}
template <class Head, class... Tail>
void ce(Head &&head, Tail &&...tail) {
if constexpr (sizeof...(tail) == 0) std::cerr << head << '\n';
else std::cerr << head << ' ', ce(std::forward<Tail>(tail)...);
}
void Yes(bool is_correct = true) { std::cout << (is_correct ? "Yes\n" : "No\n"); }
void No(bool is_not_correct = true) { Yes(!is_not_correct); }
void YES(bool is_correct = true) { std::cout << (is_correct ? "YES\n" : "NO\n"); }
void NO(bool is_not_correct = true) { YES(!is_not_correct); }
void Takahashi(bool is_correct = true) { std::cout << (is_correct ? "Takahashi" : "Aoki") << '\n'; }
void Aoki(bool is_not_correct = true) { Takahashi(!is_not_correct); }
struct T {
ll val;
bool inf;
};
struct M {
using value_type = T;
static constexpr T id() {
return T(0, 0);
}
static constexpr T op(T lhs, T rhs) {
if (lhs.inf || rhs.inf)
return T(0, 1);
if (lhs.val + rhs.val >= INF)
return T(0, 1);
return T(lhs.val + rhs.val, 0);
}
};
struct S {
ll x, y;
bool inf;
};
struct F {
using value_type = S;
static constexpr S id() {
return S(1, 0, 0);
}
static constexpr S op(S lhs, S rhs) {
if (lhs.inf || rhs.inf)
return S{0, 0, 1};
return (double)lhs.x * rhs.x + lhs.x * rhs.y + lhs.y >= INF
? S(0, 0, 1)
: S(lhs.x * rhs.x, lhs.x * rhs.y + lhs.y, 0);
}
static constexpr T f(S lhs, T rhs) {
return lhs.inf ? T(0, 1)
: ((double)lhs.x * rhs.val + lhs.y >= INF ? T(0, 1)
: T(lhs.x * rhs.val + lhs.y, 0));
}
};
int main(void) {
int n, q;
cin >> n >> q;
string s;
cin >> s;
vector<T> a(n, T(1, 0));
lazy_segment_tree<M, F> lst(a);
while (q--) {
int t;
cin >> t;
if (t == 1) {
ll l, r;
cin >> l >> r;
--l;
auto fl = [&](ll m) {
auto [x, y] = lst.prod(0, m);
if (y || x > l)
return false;
else
return true;
};
auto li = meguru_binary_search(0, n + 1, fl);
auto fr = [&](ll m) {
auto [x, y] = lst.prod(0, m);
if (y || x > r)
return false;
else
return true;
};
auto ri = meguru_binary_search(0, n + 1, fr);
if (li == ri) {
lst.apply(li, S(1, r - l, 0));
} else {
auto [rk, rf] = lst.prod(0, ri);
if (!rf && rk < r)
lst.apply(ri, S(1, r - rk, 0));
auto [lk, lf] = lst.prod(0, li + 1);
if (!lf && l < lk)
lst.apply(li, S(1, lk - l, 0));
lst.apply(li + 1, ri, S(2, 0, 0));
}
} else {
ll k;
cin >> k;
--k;
auto f = [&](ll m) {
auto [x, y] = lst.prod(0, m);
if (y || x > k)
return false;
else
return true;
};
auto x = meguru_binary_search(0, n + 1, f);
co(s[x]);
}
}
return 0;
}