#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a, _b = b; i <= _b; ++i)
#define FORD(i, a, b) for (int i = a, _b = b; i >= _b; --i)
#define all(x) x.begin(), x.end()
#define uni(x) x.erase(unique(all(x)), x.end())
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define dbg(...) cerr << "[ " << #__VA_ARGS__ << " ] = ", debug(__VA_ARGS__)
template<typename T> void debug(T x) { cerr << x << "\n\n"; }
template<typename T, typename... Args> void debug(T x, Args... args) { cerr << x << " , ", debug(args...); }
// --------------------------------------------------------------------------------------------------------------------
const int maxn = 3e5 + 3;
int n, q;
bitset<maxn> state;
// --------------------------------------------------------------------------------------------------------------------
struct Qr
{
int op, a, b;
} qrs[maxn];
namespace sub1
{
bitset<505> b[505];
bool approve()
{
return n <= 200 && q <= 200;
}
void solve()
{
FOR(i, 1, n) b[0][i] = state[i];
FOR(id, 1, q)
{
b[id] = b[id - 1];
if (qrs[id].op == 0) b[id][qrs[id].a] = !b[id][qrs[id].a];
else
{
int res = 0;
FOR(i, 0, id - 1)
{
bool c = true;
FOR(j, qrs[id].a, qrs[id].b)
if (b[i][j] == 0)
{
c = false;
break;
}
res += c;
}
cout << res << '\n';
}
}
}
}
namespace sub2
{
bool approve()
{
FOR(i, 1, q) if (qrs[i].op == 1 && qrs[i].b - qrs[i].a != 1) return false;
return true;
}
int ans[maxn];
void solve()
{
set<int> se;
FOR(i, 1, n) if (state[i]) se.insert(i);
FOR(id, 1, q)
{
int op = qrs[id].op, a = qrs[id].a, b = qrs[id].b;
if (op == 0)
{
if (se.count(a))
{
ans[a] += id;
se.erase(a);
}
else
{
ans[a] -= id;
se.insert(a);
}
}
else
{
if (se.count(a))
{
cout << ans[a] + id << '\n';
}
else
{
cout << ans[a] << '\n';
}
}
}
}
}
namespace sub5
{
struct FenTree
{
vector<ll> fw;
void init() {fw.assign(n + 3, 0);}
void upd(int pos, int val) {for (; pos <= n; pos += pos & -pos) fw[pos] += val;}
ll get(int pos)
{
int res = 0;
for (; pos; pos &= pos - 1) res += fw[pos];
return res;
}
int kth(int v)
{
if (v == 0) return 0;
int p = 0;
FORD(i, 19, 0)
if (p + (1 << i) <= n && fw[p + (1 << i)] < v)
{
v -= fw[p + (1 << i)];
p += (1 << i);
}
return p + 1;
}
} fw, fwExist;
vector<array<int, 3>> realQr[maxn], exQr[maxn];
ll ans[maxn], ansExist[maxn];
bool cmp(const int &x, const int &y) {return qrs[x].a < qrs[y].a;}
void cdq(int l, int r)
{
if (l == r) return;
int mid = l + r >> 1;
cdq(l, mid);
vector<array<int, 3>> ask_left, ask_exist; vector<int> need_right;
FOR(i, l, mid)
{
if (qrs[i].op == 1) continue;
for (const array<int, 3> &x : realQr[i])
{
ask_left.push_back(x);
}
for (const array<int, 3> &x : exQr[i])
{
ask_exist.push_back(x);
}
}
sort(all(ask_left));
sort(all(ask_exist));
int j = 0, jexist = 0;
FOR(i, mid + 1, r)
{
if (qrs[i].op == 0) continue;
need_right.push_back(i);
}
sort(all(need_right), cmp);
for (int i : need_right)
{
if (qrs[i].op == 0) continue;
while (j < (int)ask_left.size() && ask_left[j][0] <= qrs[i].a)
{
fw.upd(ask_left[j][1], ask_left[j][2]);
++j;
}
while (jexist < (int)ask_exist.size() && ask_exist[jexist][0] <= qrs[i].a)
{
fwExist.upd(ask_exist[jexist][1], ask_exist[jexist][2]);
++jexist;
}
ans[i] += fw.get(n) - fw.get(qrs[i].b - 1);
ansExist[i] += fwExist.get(n) - fwExist.get(qrs[i].b - 1);
}
FOR(i, 0, j - 1) fw.upd(ask_left[i][1], -ask_left[i][2]);
FOR(i, 0, jexist - 1) fwExist.upd(ask_exist[i][1], -ask_exist[i][2]);
cdq(mid + 1, r);
}
void solve()
{
FenTree fwCanh;
fwCanh.init();
fw.init();
fwExist.init();
FOR(i, 1, n) fwCanh.upd(i, 1);
FOR(i, 1, n)
{
if (!state[i]) continue;
fwCanh.upd(i, -1);
int x = fwCanh.get(i);
int l = fwCanh.kth(x) + 1, r = fwCanh.kth(x + 1) - 1;
exQr[0].push_back({l, r, 1});
if (l <= i - 1) exQr[0].push_back({l, i - 1, -1});
if (i + 1 <= r) exQr[0].push_back({i + 1, r, -1});
}
FOR(id, 1, q)
{
if (qrs[id].op == 1) continue;
int pos = qrs[id].a;
if(state[pos] == 0)
{
fwCanh.upd(pos, -1);
int x = fwCanh.get(pos);
int l = fwCanh.kth(x) + 1, r = fwCanh.kth(x + 1) - 1;
realQr[id].push_back({l, r, -id});
if (l <= pos - 1) realQr[id].push_back({l, pos - 1, id});
if (pos + 1 <= r) realQr[id].push_back({pos + 1, r, id});
exQr[id].push_back({l, r, 1});
if (l <= pos - 1) exQr[id].push_back({l, pos - 1, -1});
if (pos + 1 <= r) exQr[id].push_back({pos + 1, r, -1});
}
else
{
int x = fwCanh.get(pos);
int l = fwCanh.kth(x) + 1, r = fwCanh.kth(x + 1) - 1;
realQr[id].push_back({l, r, id});
fwCanh.upd(pos, 1);
if (l <= pos - 1) realQr[id].push_back({l, pos - 1, -id});
if (pos + 1 <= r) realQr[id].push_back({pos + 1, r, -id});
exQr[id].push_back({l, r, -1});
if (l <= pos - 1) exQr[id].push_back({l, pos - 1, 1});
if (pos + 1 <= r) exQr[id].push_back({pos + 1, r, 1});
}
state[pos] = !state[pos];
// for (const array<int, 3> &x : realQr[id]) dbg(x[0], x[1], x[2]);
}
cdq(0, q);
FOR(id, 1, q)
{
if (qrs[id].op == 0) continue;
if (ansExist[id]) ans[id] += id;
cout << ans[id] << '\n';
}
}
}
void solve()
{
cin >> n >> q;
FOR(i, 1, n)
{
char ch; cin >> ch;
state[i] = ch - '0';
}
FOR(i, 1, q)
{
string op; cin >> op >> qrs[i].a;
if (op[0] == 't') qrs[i].op = 0;
else qrs[i].op = 1, cin >> qrs[i].b, --qrs[i].b;
}
// if (sub2 :: approve()) return sub2 :: solve(), void();
// if (sub1 :: approve()) return sub1 :: solve(), void();
sub5 :: solve();
}
signed main()
{
ios_base::sync_with_stdio(false); cin.tie(NULL); cout.tie(NULL);
#define TASK "TEST"
if (fopen(TASK".INP", "r"))
{
freopen(TASK".INP", "r", stdin);
freopen(TASK".OUT", "w", stdout);
}
solve();
return 0;
}
/* NOTES:
pre[r] - pre[l - 1] = 0
*/
