#include <bits/stdc++.h>

using namespace std;
using ll = long long;

#define all(x) (x).begin(), (x).end()
#define sz(x) (int)(x).size()
#define pb push_back
#define ff first
#define sc second

struct query {
    int l, r, i;
};

struct seg {
    int l, r, val;
};

struct fenwick {
    int n, step;
    vector<ll> t, used;
    fenwick() = default;
    fenwick(int n_) {
        n = n_; step = 1;
        t.assign(n + 1, 0);
        used.assign(n + 1, 0);
    }
 
    void upd(int p, int vl) {
        for (; p <= n; p = (p | (p + 1))) {
            if (used[p] != step) {
                t[p] = 0; used[p] = step;
            }
            t[p] += vl;
        }
    }
 
    ll get(int p) {
        ll sm = 0;
        for (; p > 0; p = (p & (p + 1)) - 1) {
            if (used[p] != step) {
                t[p] = 0; used[p] = step;
            }
            sm += t[p];
        }
        return sm;
    }
};

void solve() {
    int n, q; cin >> n >> q;
    string s; cin >> s;

    vector<vector<query>> qs(4 * q);
    vector<vector<int>> upds(4 * q);
    vector<vector<pair<int, int>>> sgtv(q);
    vector<ll> ans(q);
    auto build = [&](int v, int l, int r, auto&&self) -> void {
        sgtv[l].pb({v, r});
        if (l + 1 == r) return;
        int mid = (l + r) / 2;
        self(v * 2, l, mid, self); self(v * 2 + 1, mid, r, self);
    };
    auto add_query = [&](int v, int l, int r, int pr, query Q, auto&&self) -> void {
        if (l >= pr) return;
        if (r <= pr) {
            qs[v].pb(Q);
            return;
        }
        int mid = (l + r) / 2;
        self(v * 2, l, mid, pr, Q, self);
        self(v * 2 + 1, mid, r, pr, Q, self);
    };  
    build(1, 0, q, build);
    vector<pair<int, int>> typ(q, {0, -1});
    int nq = 0;
    vector<pair<query, int>> gq;
    for (int i = 0; i < q; i++) {
        string type; cin >> type;
        if (type[0] == 'q') {
            int l, r; cin >> l >> r;
            l--; r-=2;
            gq.pb({{l, r, nq++}, i + 1});
            //add_query(1, 0, q, i + 1, {l, r, nq++}, add_query);
        } else {
            int ind; cin >> ind;
            ind--;
            if (i + 1 < q) {
                typ[i + 1] = {1, ind};
            }
        }
    }
    sort(all(gq), [](pair<query, int> q1, pair<query, int> q2){
        return q1.first.l < q2.first.l;
    });
    for (auto [qq, pp] : gq) {
        add_query(1, 0, q, pp, qq, add_query);
    }
    // for (int i = 0; i < q; i++) {
    //     cout << typ[i].first << ' ';
    // }
    // cout << '\n';
    // auto deb = [&](int v, int tl, int tr, auto&&self) -> void {
    //     cout << tl << ' ' << tr << '\n';
    //     for (auto Q : qs[v]) {
    //         cout << Q.i << ' ' << Q.l << ' ' << Q.r << '\n';
    //     }
    //     if (tl +1  == tr) return;
    //     int tm = (tl + tr) / 2;
    //     self(v * 2, tl, tm, self); self(v * 2 + 1, tm, tr, self);
    // };
    // deb(1, 0, q, deb);
    // return;
    // -----------------------------
    vector<pair<int, int>> seg_in(q, {-1, -1});
    vector<int> nxt(n, -1), prv(n, -1);
    set<int> starts;
    int curst = -1;
    s += '0';
    for (int i = 0; i <= n; i++) {
        if (s[i] == '0') {
            if (curst != -1) {
                nxt[curst] = i - 1;
                prv[i - 1] = curst;
                starts.insert(curst);
            }
            curst = -1;
        } else {
            if (curst == -1) curst = i;
        }
    }
    set<int> os = starts;
    vector<int> chng_nxt = nxt, chng_prv = prv;
    string ns = s;
    for (int l = 0; l < q; l++) {
        if (typ[l].first) {
            if (ns[typ[l].second] == '1') {
                auto it = --starts.lower_bound(typ[l].second + 1);
                int st = *it;
                int endd = chng_nxt[st];
                seg_in[l] = {st, endd};
                if (st < typ[l].second) {
                    chng_nxt[st] = typ[l].second - 1;
                    chng_prv[typ[l].second - 1] = st;
                } else {
                    chng_nxt[st] = -1;
                    starts.erase(st);
                }

                if (endd > typ[l].second) {
                    chng_nxt[typ[l].second + 1] = endd;
                    chng_prv[endd] = typ[l].second + 1;
                    starts.insert(typ[l].second + 1);
                } else {
                    chng_prv[endd] = -1;
                }
                ns[typ[l].second] = '0';
            } else {
                int curst = typ[l].second, curendd = typ[l].second;
                if (typ[l].second - 1 >= 0 && chng_prv[typ[l].second - 1] != -1) {
                    curst = chng_prv[typ[l].second - 1];
                    chng_prv[typ[l].second - 1] = -1;
                }
                if (typ[l].second + 1 < n && chng_nxt[typ[l].second + 1] != -1) {
                    curendd = chng_nxt[typ[l].second + 1];
                    starts.erase(typ[l].second + 1);
                    chng_nxt[typ[l].second + 1] = -1;
                }
                starts.insert(curst);
                chng_nxt[curst] = curendd;
                chng_prv[curendd] = curst;
                ns[typ[l].second] = '1';
            }
        }
    }
    //return;
    // ----------------------------
    // s - current string
    // nxt, prv - current values
    // dont forget to otk nxt and prv after considering vertex 

    starts = os;
    fenwick fw(n + 3);
    vector<vector<query>> to_check(q);
    auto solve_vertex = [&](int v, int l, int r) {
        fw.step++;
        //bool whole = false;
        for (auto Q : qs[v]) {
            //if (Q.i == 4) whole = true;
           // if (Q.i == 4) cout << s[Q.l] << '\n';
            if (s[Q.l] == '1') {
                auto it = --starts.lower_bound(Q.l + 1);
                if (nxt[*it] >= Q.r) {
                    ans[Q.i] -= l;
                }
            }
        }
        vector<seg> sgs;
        vector<pair<int, int>> upds_nxt, upds_prv;
        for (int i = l + 1; i < r; i++) {
            if (typ[i].first) {
                if (s[typ[i].second] == '1') {
                    pair<int, int> sg = seg_in[i];
                    sgs.pb({sg.first, sg.second, i});
                    if (sg.first < typ[i].second) {
                        sgs.pb({sg.first, typ[i].second - 1, -i});
                        upds_nxt.pb({sg.first, sg.second});
                        nxt[sg.first] = typ[i].second - 1;
                        upds_prv.pb({typ[i].second - 1, -1});
                        prv[typ[i].second - 1] = sg.first;
                    } else {
                        upds_nxt.pb({typ[i].second, sg.second});
                        nxt[typ[i].second] = -1;
                    }
                    if (sg.second != typ[i].second) {
                        sgs.pb({typ[i].second + 1, sg.second, -i});
                        upds_nxt.pb({typ[i].second + 1, -1});
                        nxt[typ[i].second + 1] = sg.second;
                        upds_prv.pb({sg.second, sg.first});
                        prv[sg.second] = typ[i].second + 1;
                    } else {
                        upds_prv.pb({typ[i].second, sg.first});
                        prv[typ[i].second] = -1;
                    }
                    s[typ[i].second] = '0';
                } else {
                    int ST = typ[i].second, ED = typ[i].second;
                    if (typ[i].second > 0 && prv[typ[i].second - 1] != -1) {
                        sgs.pb({prv[typ[i].second - 1], typ[i].second - 1, i});
                        ST = prv[typ[i].second - 1];
                        upds_prv.pb({typ[i].second - 1, prv[typ[i].second - 1]});
                        prv[typ[i].second - 1] = -1;
                    }
                    if (typ[i].second + 1 < n && nxt[typ[i].second + 1] != -1) {
                        sgs.pb({typ[i].second + 1, nxt[typ[i].second + 1], i});
                        ED = nxt[typ[i].second + 1];
                        upds_nxt.pb({typ[i].second + 1, nxt[typ[i].second + 1]});
                        nxt[typ[i].second + 1] = -1;
                    }
                    sgs.pb({ST, ED, -i});
                    upds_nxt.pb({ST, nxt[ST]});
                    nxt[ST] = ED;
                    upds_prv.pb({ED, prv[ED]});
                    prv[ED] = ST;
                    s[typ[i].second] = '1';
                }
            }
        }
        for (int i = r - 1; i > l; i--) {
            if (typ[i].first) {
                s[typ[i].second] = (s[typ[i].second] == '0' ? '1' : '0');
            }
        }

        for (int i = sz(upds_nxt) - 1; i >= 0; i--) {
            //if (v == 3) cout << upds_nxt[i].first << ' ' << upds_nxt[i].second << " upds\n";
            nxt[upds_nxt[i].first] = upds_nxt[i].second;
        }
        for (int i = sz(upds_prv) - 1; i >= 0; i--) {
            prv[upds_prv[i].first] = upds_prv[i].second;
        }

        sort(all(sgs), [](seg x, seg y) {
            return x.l < y.l;
        });
        // if (whole) {
        //     cout << "y " << l << ' ' << r << '\n';
        //     for (auto sg : sgs) {
        //         cout << sg.l << ' ' << sg.r << ' ' << sg.val << '\n';
        //     }
        // }
        ll S = 0;
        int ind_ud = 0;
        for (int i = 0; i < sz(qs[v]); i++) {
            while (ind_ud < sz(sgs) && sgs[ind_ud].l <= qs[v][i].l) {
                S += sgs[ind_ud].val;
                fw.upd(sgs[ind_ud].r + 1, sgs[ind_ud].val);
                ind_ud++;
            }
            ans[qs[v][i].i] += S - fw.get(qs[v][i].r);
            to_check[r - 1].pb(qs[v][i]);
        }
    };  

    for (int l = 0; l < q; l++) {
        //cout << l << " newl\n";
        if (typ[l].first) {
            if (s[typ[l].second] == '1') {
                auto it = --starts.lower_bound(typ[l].second + 1);
                int st = *it;
                int endd = nxt[st];
                if (st < typ[l].second) {
                    nxt[st] = typ[l].second - 1;
                    prv[typ[l].second - 1] = st;
                } else {
                    nxt[st] = -1;
                    starts.erase(st);
                }

                if (endd > typ[l].second) {
                    nxt[typ[l].second + 1] = endd;
                    prv[endd] = typ[l].second + 1;
                    starts.insert(typ[l].second + 1);
                } else {
                    prv[endd] = -1;
                }
                s[typ[l].second] = '0';
            } else {
                int curst = typ[l].second, curendd = typ[l].second;
                if (typ[l].second - 1 >= 0 && prv[typ[l].second - 1] != -1) {
                    curst = prv[typ[l].second - 1];
                    prv[typ[l].second - 1] = -1;
                }
                if (typ[l].second + 1 < n && nxt[typ[l].second + 1] != -1) {
                    curendd = nxt[typ[l].second + 1];
                    starts.erase(typ[l].second + 1);
                    nxt[typ[l].second + 1] = -1;
                }
                starts.insert(curst);
                nxt[curst] = curendd;
                prv[curendd] = curst;
                s[typ[l].second] = '1';
            }
        }
        //cout << s << '\n';
        for (auto [vt, rg] : sgtv[l]) {
            solve_vertex(vt, l, rg);
            //cout << vt << ' ' << l << ' ' << rg << ' ' << s << '\n';
            // cout << "after solved vertex " << vt << ' ' << l << ' ' << rg << '\n';
            // for (int u : nxt) cout << u << ' ';
            // cout << '\n';
            // for (int u : prv) cout << u << ' ';
            // cout << '\n';
        }
        for (auto QQ : to_check[l]) {
            if (s[QQ.l] == '1') {
                auto it = --starts.lower_bound(QQ.l + 1);
                //if (QQ.i == 5) cout << *it << ' ' << nxt[*it] << '\n';
                if (nxt[*it] >= QQ.r) {
                    ans[QQ.i] += (l + 1);
                }
            }
        }
        to_check[l].clear();
    }
    // ----------------------------
    for (int i = 0; i < nq; i++) {
        cout << ans[i] << '\n';
    }
}

signed main() {
    int tt = 1;
    #ifdef LOCAL 
        freopen("in.txt", "r", stdin);
        freopen("out.txt", "w", stdout);
    #else
        ios::sync_with_stdio(false); 
        cin.tie(0); cout.tie(0);
    #endif

    while (tt--) {
        solve();
    }

    return 0;
}