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

using ll = long long;
#define rep(i, n) for(ll i = 0; i < (n); ++i)
#define rep2(i, l, r) for(ll i = (l); i < (r); ++i)

using vi = vector<int>;
using vvi = vector<vi>;
using vll = vector<ll>;

#define all(A) A.begin(), A.end()
#define elif else if
using pii = pair<ll, ll>;

bool chmin(auto &a, auto b) {return a > b ? a = b, 1 : 0;}
bool chmax(auto &a, auto b) {return a < b ? a = b, 1 : 0;}

struct IOS {
  IOS() {
    cin.tie(0);
    ios::sync_with_stdio(0);
  }
} iosetup;

template<class T>
void print(vector<T> a) {
  for(auto x : a) cout << x << ' ';
  cout << endl;
}

void print(auto x) {cout << x << endl;}

template<class Head, class... Tail>
void print(Head &&head, Tail &&...tail) {
  cout << head << ' ';
  print(forward<Tail>(tail)...);
}

template<class S, S(*op)(S, S), S(*e)(), class F, S(*mp)(F, S), F(*cmp)(F, F), F(*id)()>
struct lazysegtree {
  int N, sz, log;
  vector<S> d;
  vector<F> lz;

  lazysegtree() = default;
  lazysegtree(int n) : lazysegtree(vector<S>(n, e())) {};
  lazysegtree(vector<S> v) {
    N = v.size();
    sz = 1, log = 0;
    while(sz < N) sz *= 2, log++;
    d.assign(2*sz, e());
    lz.assign(2*sz, id());
    rep(i, N) d[i+sz] = v[i];
    for(int i = sz-1; i > 0; --i) d[i] = op(d[2*i], d[2*i+1]);
  }

  void update(int k) {d[k] = op(d[2*k], d[2*k+1]);}
  void all_apply(int k, F f) {
    d[k] = mp(f, d[k]);
    if(k < sz) lz[k] = cmp(f, lz[k]);
  }
  void push(int k) {
    all_apply(2*k, lz[k]);
    all_apply(2*k+1, lz[k]);
    lz[k] = id();
  }
  void PUSH(int k) {
    for(int i = log; i > 0; --i) push(k >> i);
  }

  bool shift(int x, int i) {return ((x>>i)<<i)!= x;}

  S prod(int l, int r) {
    if(l == r) return e();
    l += sz, r += sz;
    for(int i = log; i > 0; i--) {
      if(shift(l, i)) push(l>>i);
      if(shift(r, i)) push((r-1)>>i);
    }
    S sml = e(), smr = e();
    while(l < r) {
      if(l&1) sml = op(sml, d[l++]);
      if(r&1) smr = op(d[--r], smr);
      l >>= 1, r >>= 1;
    }
    return op(sml, smr);
  }

  void apply(int l, int r, F f) {
    if(l==r) return;
    l += sz, r += sz;
    for(int i = log; i > 0; --i) {
      if(shift(l, i)) push(l>>i);
      if(shift(r, i)) push((r-1)>>i);
    }
    int ml = l, mr = r;
    while(l < r) {
      if(l&1) all_apply(l++, f);
      if(r&1) all_apply(--r, f);
      l >>= 1, r >>= 1;
    }
    l = ml, r = mr;
    rep2(i, 1, log+1) {
      if(shift(l, i)) update(l >> i);
      if(shift(r, i)) update((r-1)>>i);
    }
  }

  void set(int p, S x) {
    p += sz;
    PUSH(p);
    d[p] = x;
    rep2(i, 1, log+1) update(p >> i);
  }

  template<class C>
  int max_right(int l, C check) {
    assert(check(e()));
    if(l == N) return N;
    l += sz;
    PUSH(l);
    S sm = e();
    do {
      while(~l & 1) l >>= 1;
      if(!check(op(sm, d[l]))) {
        while(l < sz) {
          push(l);
          l <<= 1;
          if(check(op(sm, d[l]))) {
            sm = op(sm, d[l]);
            l++;
          }
        }
        return l - sz;
      }
      sm = op(sm, d[l]);
      l++;
    } while((l & -l) != l);
    return N;
  }

};


ll op(ll a,ll b){return a+b;}
ll e(){return 0;}
ll mapping(ll f,ll x){return f*x;}
ll cmp(ll f,ll g){return f*g;}
ll id(){return 1;}

ll target;
bool f(ll x){return x<=target;}

int main(){
  int n,q;
  cin>>n>>q;
  string s;
  cin>>s;
  vll init(n,1);
  lazysegtree<ll,op,e,ll,mapping,cmp,id>seg(init);

  auto get=[&](ll x)->int{
    target=x;
    return seg.max_right(0,f);
  };

  rep(i,q){
    int t;
    cin>>t;
    if(t==1){
      ll l,r;
      cin>>l>>r;
      l--;
      // r--;
      int idxl=get(l);
      int idxr=get(r);
      if(idxl==idxr){
        ll len=seg.prod(idxl,idxl+1);
        seg.set(idxl,len+(r-l));
      }
      else{
        int left1=seg.prod(0,idxl);
        ll len1=seg.prod(idxl,idxl+1);

        int left2=seg.prod(0,idxr);
        ll len2=seg.prod(idxr,idxr+1);
        
        {
          seg.set(idxl,2*len1-(l-left1));
        }

        {
          seg.apply(idxl+1,idxr,2);
        }
        {
          seg.set(idxr,len2+(r-left2));
        }
      }
      // rep(i,n)cout<<seg.prod(i,i+1)<<" ";
      // cout<<endl;
    }
    else{
      ll idx;
      cin>>idx;
      idx--;
      cout<<s[get(idx)]<<"\n";
    }
  }
}