#include <iostream>
#include <string>
#include <vector>

using namespace std;

// Структура на възела със "по-бавен", но интуитивен 2D преход
struct SlowerNode {
    long long len;
    long long ans;
    
    // trans[i][j] = 1 ако, започвайки от състояние i, приключваме в j (иначе 0)
    int trans[6][6]; 
    
    // words[i] = брой генерирани думи "bessie", ако влезем със състояние i
    long long words[6]; 
    
    // pref[i] = сумата от думите във всички префикси, стартирайки от i
    long long pref[6];
    
    // suf_cnt[j] = брой суфикси, които приключват в състояние j (стартирайки от 0)
    long long suf_cnt[6];
    
    // suf_words[j] = сумата от генерираните думи в тези суфикси
    long long suf_words[6];
};

// Функция за създаване на листо (отговарящо на 1 символ)
SlowerNode make_leaf(char c) {
    SlowerNode res;
    res.len = 1;
    res.ans = 0;
    
    for(int i = 0; i < 6; ++i) {
        res.words[i] = 0;
        res.pref[i] = 0;
        res.suf_cnt[i] = 0;
        res.suf_words[i] = 0;
        for(int j = 0; j < 6; ++j) res.trans[i][j] = 0;
    }
    
    string target = "bessie";
    for(int i = 0; i < 6; ++i) {
        if(c == target[i]) {
            if(i == 5) {
                res.trans[i][0] = 1; // Завършваме думата и се връщаме в 0
                res.words[i] = 1;
            } else {
                res.trans[i][i+1] = 1; // Успешно продължаваме напред
            }
        } else {
            res.trans[i][i] = 1; // Символът не помага, оставаме в същото състояние
        }
        res.pref[i] = res.words[i];
    }
    
    // Единственият суфикс тук е самият символ. Суфиксите винаги стартират от състояние 0.
    int end_state = 0;
    for(int j = 0; j < 6; ++j) {
        if(res.trans[0][j]) end_state = j;
    }
    
    res.suf_cnt[end_state] = 1;
    res.suf_words[end_state] = res.words[0];
    
    return res;
}

// Функция за сливане (умишлено разделена на стъпки с ясни цикли)
SlowerNode merge_slower(const SlowerNode& L, const SlowerNode& R) {
    SlowerNode res;
    res.len = L.len + R.len;
    res.ans = L.ans + R.ans; // Започваме със сбора от изцяло вътрешните поднизове
    
    for(int i = 0; i < 6; ++i) {
        res.words[i] = 0;
        res.pref[i] = 0;
        res.suf_cnt[i] = 0;
        res.suf_words[i] = 0;
        for(int j = 0; j < 6; ++j) res.trans[i][j] = 0;
    }
    
    // 1. Комбиниране на преходите и префиксите (от i през j до k)
    for(int i = 0; i < 6; ++i) {
        for(int j = 0; j < 6; ++j) {
            if(L.trans[i][j]) {
                for(int k = 0; k < 6; ++k) {
                    if(R.trans[j][k]) {
                        res.trans[i][k] = 1;
                    }
                }
                res.words[i] = L.words[i] + R.words[j];
                res.pref[i] = L.pref[i] + L.words[i] * R.len + R.pref[j];
            }
        }
    }
    
    // 2. Комбиниране на суфиксите
    for(int j = 0; j < 6; ++j) {
        // А. Суфикси, които са изцяло в дясното дете
        res.suf_cnt[j] += R.suf_cnt[j];
        res.suf_words[j] += R.suf_words[j];
        
        // Б. Суфикси от лявото дете, които продължават и преминават през дясното
        if (L.suf_cnt[j] > 0) {
            for(int k = 0; k < 6; ++k) {
                if (R.trans[j][k]) {
                    res.suf_cnt[k] += L.suf_cnt[j];
                    res.suf_words[k] += L.suf_words[j] + L.suf_cnt[j] * R.words[j];
                }
            }
        }
    }
    
    // 3. Пресичащи се поднизове (Суфикс от Ляво + Префикс от Дясно)
    for(int j = 0; j < 6; ++j) {
        if (L.suf_cnt[j] > 0) {
            // Всяка дума от суфикса се появява R.len пъти (с всеки един префикс отдясно)
            // Плюс думите, които се образуват вътре в самите префикси отдясно
            res.ans += L.suf_words[j] * R.len + L.suf_cnt[j] * R.pref[j];
        }
    }
    
    return res;
}

const int MAXN = 200005;
SlowerNode tree[4 * MAXN];
string S;

void build(int node, int start, int end) {
    if (start == end) {
        tree[node] = make_leaf(S[start]);
        return;
    }
    int mid = (start + end) / 2;
    build(2 * node, start, mid);
    build(2 * node + 1, mid + 1, end);
    tree[node] = merge_slower(tree[2 * node], tree[2 * node + 1]);
}

void update(int node, int start, int end, int idx, char val) {
    if (start == end) {
        tree[node] = make_leaf(val);
        return;
    }
    int mid = (start + end) / 2;
    if (idx <= mid) {
        update(2 * node, start, mid, idx, val);
    } else {
        update(2 * node + 1, mid + 1, end, idx, val);
    }
    tree[node] = merge_slower(tree[2 * node], tree[2 * node + 1]);
}

int main() {
    // Оптимизация на входа/изхода за задачи с много заявки
    ios_base::sync_with_stdio(false);
    cin.tie(NULL);
    
    if (!(cin >> S)) return 0;
    int U;
    cin >> U;
    
    int n = S.size();
    build(1, 0, n - 1);
    
    cout << tree[1].ans << "\n";
    while (U--) {
        int p; 
        char c;
        cin >> p >> c;
        update(1, 0, n - 1, p - 1, c);
        cout << tree[1].ans << "\n";
    }
    
    return 0;
}
