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

using i32 = int32_t;
using i64 = int64_t;
#define i128 __int128_t
using u32 = uint32_t;
using u64 = uint64_t;
using f64 = long double;

template<class T>
using lque = priority_queue<T, vector<T>, greater<T>>;
// -------------------
con i32 MX = 2e5 + 7;
con i32 MXL = MX*2;

i32 n, m;
string ip;

i32 ite;
i32 lb[MXL], rb[MXL], ln[MXL], rn[MXL];
struct Tag{
    i64 sum, num;
} tag[MXL];
bool lzy[MXL];

void merge_up(i32 u) {
    if(rb[u]-lb[u]==1) return;
    auto &lt = tag[ln[u]], &rt = tag[rn[u]];
    tag[u].sum = lt.sum + rt.sum;
    tag[u].num = lt.num + rt.num;
    lzy[u] = false;
}

void flip_lzy(i32 u) {
    auto calc_sz = [](i64 l, i64 r) -> i64 {
        return (l+r-1)*(r-l)/2;
    };
    tag[u].sum = calc_sz(lb[u], rb[u]) - tag[u].sum;
    tag[u].num = rb[u]-lb[u] - tag[u].num;
    lzy[u] ^= 1;
}

void lzy_down(i32 u) {
    if(lzy[u]&&rb[u]-lb[u]!=1) {
        flip_lzy(ln[u]);
        flip_lzy(rn[u]);
    }
    lzy[u] = false;
}

void flip(i32 l, i32 r, i32 u) {
    if(l<=lb[u]&&rb[u]<=r) flip_lzy(u);
    else {
        lzy_down(u);
        con i32 mid = rb[ln[u]];
        if(l<mid) flip(l, min(mid, r), ln[u]);
        if(mid<r) flip(max(l, mid), r, rn[u]);
        merge_up(u);
    }
}

void solve() {
    for(i32 i=0, l, r; i<m; ++i) {
        cin >> l >> r;
        flip(l-1, r, 0);
        // cout << tag[0].sum << ' ';
        // cout << tag[0].num << '\n';
        cout << 2*tag[0].sum-tag[0].num*(tag[0].num-2) << '\n';
    }
}

void build_tree(i32 l, i32 r) {
    auto u = ite++;
    lb[u] = l; rb[u] = r; lzy[u] = 0;
    if(l+1<r) {
        con i32 mid = (l+r) / 2;
        ln[u] = ite; build_tree(l, mid);
        rn[u] = ite; build_tree(mid, r);
        merge_up(u);
    } else {
        if(ip[l]=='1') tag[u] = {l, 1};
        else tag[u] = {0, 0};
    }
}

void pre() {
    if(!(cin >> n >> m >> ip)) exit(0);
    build_tree(ite=0, n);
}

void init() {
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
}

int main() {
    init();
    for(;;) {
        pre();
        solve();
    }
}