#include <cstdio>

 #include <cstdlib>

 #include <iostream>

 #include <algorithm>

 #include <vector>

 using namespace std;

 typedef unsigned long long ull;

 const int x = ;

 const int maxn = 4e5 + ;

 ull xp[maxn];

 int n, m;

 struct Node {

     Node* ch[];

     int r, v, s;

     int val;

     ull Hush[];

     int flip;

     Node(int v1, int v2): v(v1), val(v2) {

         r = rand();

         s = ;

         ch[] = ch[] = NULL;

         flip = ;

         Hush[] = Hush[] = val;

     }

     bool cmp(const int &x) const {

         if(x == v) return -;

         return x < v ?  : ;

     }

     void maintain() {

         s = ;

         Hush[] = Hush[] = val;

         if(ch[] != NULL) s += ch[]->s, Hush[] = ch[]->Hush[ch[]->flip] + val*xp[ch[]->s];

         if(ch[] != NULL) Hush[] += (ch[]->Hush[ch[]->flip])*xp[s], s += ch[]->s;

         int s2 = ;

         if(ch[] != NULL) s2 += ch[]->s, Hush[] = ch[]->Hush[(ch[]->flip)^] + val*xp[ch[]->s];

         if(ch[] != NULL) Hush[] += (ch[]->Hush[(ch[]->flip)^])*xp[s2];

     }

     void pushdown() {

         if(flip) {

             flip = ;

             swap(ch[], ch[]);

             if(ch[] != NULL) ch[]->flip = !ch[]->flip;

             if(ch[] != NULL) ch[]->flip = !ch[]->flip;

         }

     }

 };

 void rotate(Node* &o, int d) {

     Node* k = o->ch[d^]; o->ch[d^] = k->ch[d]; k->ch[d] = o;

     o->maintain(); k->maintain(); o = k;

 }

 void insert(Node* &o, int x, int val) {

     if(o == NULL) o = new Node(x, val);

     else {

         int d = o->cmp(x);

         insert(o->ch[d], x, val);

         if(o->ch[d]->r > o->r) rotate(o, d^);

     }

     o->maintain();

 }

 void splay(Node* &o, int k) {

     o->pushdown();

     int s = o->ch[] == NULL ?  : o->ch[]->s;

     int d = k <= s ?  : (k == s+? - : );

     if(d == ) k -= s+;

     if(d != -) {

         splay(o->ch[d], k);

         rotate(o, d^);

     }

 }

 Node * merge(Node* left, Node* right) {

     splay(left, left->s);

     left->ch[] = right;

     left->maintain();

     return left;

 }

 void split(Node* o, int k , Node* &left, Node* &right) {

     splay(o, k);

     left = o;

     right = o->ch[];

     o->ch[] = NULL;

     left->maintain();

 }

 void oper1(Node* &o, int p, int c) {

     Node* left, *right;

     Node* node = new Node(p+, c);

     split(o, p+, left, right);

     o = merge(merge(left, node), right);

 }

 void oper2(Node* &o, int p) {

     Node* left, *mid, *right;

     split(o, p, left, mid);

     split(mid, , mid, right);

     o = merge(left, right);

 }

 void oper3(Node* &o, int p1, int p2) {

     Node *left, *mid, *right;

     split(o, p1, left, mid);

     split(mid, p2-p1+, mid, right);

     mid->flip ^= ;

     o = merge(merge(left, mid), right);

 }

 ull Hush_val(Node* &o, int p, int L) {

     Node *left, *mid, *right;

     split(o, p, left, mid);

     split(mid, L, mid, right);

     ull ans =  mid->Hush[mid->flip];

     o = merge(merge(left, mid), right);

     return ans;

 }

 int oper4(Node* &o, int p1, int p2) {

     int L = , R = min(n-p1+, n-p2+);

     while(L < R) {

         int M = R - (R-L)/;

         int l1 = Hush_val(o, p1, M), l2 =  Hush_val(o, p2, M);

         if(l1 == l2) L = M;

         else R = M-;

     }

     return L;

 }

 char s[maxn];

 int main() {

     xp[] = ;

     for(int i = ; i < maxn; i++) xp[i] = xp[i-]*x;

     while(scanf("%d%d", &n, &m) == ) {

         scanf("%s", s);

         Node* root = new Node(, );

         for(int i = ; i < n; i++) {

             int c = s[i] - '';

             insert(root, i+, c);

         }

         for(int i = ; i < m; i++) {

             int id, p1, p2;

             scanf("%d", &id);

             if(id == ) {

                 scanf("%d%d", &p1, &p2);

                 oper1(root, p1, p2);

                 n++;

             }

             if(id == ) {

                 scanf("%d", &p1);

                 oper2(root, p1);

                 n--;

             }

             if(id == ) {

                 scanf("%d%d", &p1, &p2);

                 oper3(root, p1, p2);

             }

             if(id == ) {

                 scanf("%d%d", &p1, &p2);

                 int ans = oper4(root, p1, p2);

                 printf("%d\n", ans);

             }

         }

     }

     return ;

 }