#include<bits/stdc++.h>
using namespace std;

using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
using ii = pair<int, int>;
using vii = vector<ii>;

#define rep(i, a, b) for (int i = a; i < b; i++)
#define all(x) x.begin(), x.end()
#define pb(x) push_back(x)

const int MX = 3e5;

struct Segtree {
    vll st, lazy;
    int n;

    void build(vll &nums, int v, int tl, int tr) {
        if (tl == tr) {
            st[v] = nums[tl];
            return;
        }

        int mid = (tl + tr) / 2;
        build(nums, 2 * v, tl, mid);
        build(nums, 2 * v + 1, mid + 1, tr);
        st[v] = st[2 * v] + st[2 * v + 1];
    }

    void build(vll &nums) {
        n = nums.size();
        st.resize(4 * n);
        lazy.resize(4 * n);
        build(nums, 1, 0, n - 1);
    }

    void rangeUpdate(int v, int tl, int tr, int l, int r) {
        if (tl >= l && tr <= r) {
            st[v] *= 2ll;
            lazy[v]++;
            return;
        }

        if (tl > r || tr < l) return;
        push(v);
        int mid = (tl + tr) / 2;
        rangeUpdate(2 * v, tl, mid, l, r);
        rangeUpdate(2 * v + 1, mid + 1, tr, l, r);
        st[v] = st[2 * v] + st[2 * v + 1];
    }

    void rangeUpdate(ll l, ll r) {
        int tl = kth(l), tr = kth(r);
        rangeUpdate(1, 0, n - 1, tl + 1, tr - 1);
        if (tl == tr) {
            pointUpdate(tl, r - l + 1ll);
        }else {
            pointUpdate(tr, r - sum(0, tr - 1));
            pointUpdate(tl, sum(0, tl) - l + 1ll);
            
        }
    }

    void pointUpdate(int v, int tl, int tr, int pos, ll x) {
        if (tl == tr) {
            st[v] += x;
            return;
        }
        push(v);
        int mid = (tl + tr) / 2;
        if (pos <= mid)
            pointUpdate(2 * v, tl, mid, pos, x);
        else 
            pointUpdate(2 * v + 1, mid + 1, tr, pos, x);
        st[v] = st[2 * v] + st[2 * v + 1];
    }

    void pointUpdate(int pos, ll x) {
        pointUpdate(1, 0, n - 1, pos, x);
    }   

    ll sum(int v, int tl, int tr, int l, int r) {
        if (tl >= l && tr <= r) return st[v];
        if (tl > l || tr < l) return 0;
        push(v);
        int mid = (tl + tr) / 2;
        return sum(2 * v, tl, mid, l, r) + sum(2 * v + 1, mid + 1, tr, l, r);
    }

    ll sum(int l, int r) {
        return sum(1, 0, n - 1, l, r);
    }

    int kth(int v, int tl, int tr, ll x) {
        if (tl == tr) return tl;
        push(v);
        int mid = (tl + tr) / 2;
        if (st[2 * v] >= x)
            return kth(2 * v, tl, mid, x);
        return kth(2 * v + 1, mid + 1, tr, x - st[2 * v]);
    }

    int kth(ll x) {
        return kth(1, 0, n - 1, x);
    }

    void push(int v) {
        if (lazy[v]) {
            lazy[2 * v] += lazy[v];
            lazy[2 * v + 1] += lazy[v];
            st[2 * v] *= 1ll << lazy[v];
            st[2 * v + 1] *= 1ll << lazy[v];
            lazy[v] = 0;
        }
    }
};

void solve() {
    int n, q; cin >> n >> q;
    string s; cin >> s;
    vll blocks;
    string chars;
    ll cur = 1;
    rep(i, 1, n) {
        if (s[i] != s[i - 1]) {
            blocks.pb(cur);
            chars.pb(s[i - 1]);
            cur = 0;
        }

        cur++;
    }

    blocks.pb(cur);
    chars.pb(s[n - 1]);

    Segtree st; st.build(blocks);

    while (q--) {
        int op; cin >> op;
        if (op == 1) {
            ll l, r; cin >> l >> r;
            st.rangeUpdate(l, r);
        }else {
            ll x; cin >> x;
            cout << chars[st.kth(x)] << "\n";
        }
    }   
}

int main() {
    ios_base::sync_with_stdio(false); cin.tie(0);
    int t = 1; //cin >> t;
    while (t--)
        solve();
}