#include <map>
#include <set>
#include <array>
#include <cmath>
#include <deque>
#include <bitset>
#include <random>
#include <string>
#include <vector>
#include <cassert>
#include <complex>
#include <iomanip>
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <unordered_set>

using namespace std;

const int K = 7;
const int INF = 1e9;

string lines[K] = {"do", "re", "mi", "fa", "so", "la", "ti"};
int dp[(1 << 20) + 228][K + 1][K + 1];

void recalc(int v, int left, int right) {
    for (int i = 0; i <= K; ++i)
        fill(dp[v][i], dp[v][i] + K + 1, INF);
    for (int i = 0; i <= K; ++i) {
        for (int j = 0; j <= K; ++j) {
            for (int l = 0; l <= K; ++l) {
                dp[v][i][l] = min(dp[v][i][l], dp[2 * v + 1][i][j] + dp[2 * v + 2][j][l]);
            }
        }
    }
    int mid = (left + right) / 2;
    for (int i = 0; i <= K; ++i) {
        for (int j = 0; j <= K; ++j) {
            dp[v][i][j] = min(dp[v][i][j], dp[2 * v + 1][i][j] + right - mid);
            dp[v][i][j] = min(dp[v][i][j], mid - left + dp[2 * v + 2][i][j]);
        }
    }
}

void upd_symbol(int v, char c) {
    // left dim is right
    // right dim is left
    for (int i = 0; i <= K; ++i)
        fill(dp[v][i], dp[v][i] + K + 1, INF);
    for (int i = 0; i < K; ++i) {
        if (c == lines[i][1])
            dp[v][i][K] = 0;
    }
    for (int i = 0; i < K; ++i) {
        if (c == lines[i][0])
            dp[v][K][i] = 0;
    }
    dp[v][K][K] = 1;
}

void build(int v, int left, int right, string& s) {
    if (left + 1 == right) {
        upd_symbol(v, s[left]);
        return;
    }
    int mid = (left + right) / 2;
    build(2 * v + 1, left, mid, s);
    build(2 * v + 2, mid, right, s);
    recalc(v, left, right);
}

void upd(int v, int left, int right, int x, int y, string& s) {
    if (y <= left || right <= x)
        return;
    if (left + 1 == right) {
        upd_symbol(v, s[left - x]);
        return;
    }
    int mid = (left + right) / 2;
    upd(2 * v + 1, left, mid, x, y, s);
    upd(2 * v + 2, mid, right, x, y, s);
    recalc(v, left, right);
}

int cur_dp[K + 1];
int tmp_cur_dp[K + 1];

void get(int v, int left, int right, int x, int y) {
    if (y <= left || right <= x)
        return;
    if (x <= left && right <= y) {
        fill(tmp_cur_dp, tmp_cur_dp + K + 1, INF);
        for (int i = 0; i <= K; ++i) {
            for (int j = 0; j <= K; ++j)
                tmp_cur_dp[j] = min(tmp_cur_dp[j], cur_dp[i] + dp[v][i][j]);
        }
        for (int i = 0; i <= K; ++i)
            cur_dp[i] = tmp_cur_dp[i];
        return;
    }
    int mid = (left + right) / 2;
    get(2 * v + 1, left, mid, x, y);
    get(2 * v + 2, mid, right, x, y);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    
    int n, q;
    cin >> n >> q;
    string s;

    /*for (int i = 0; i < n; ++i)
        s += char('a' + rand() % 26);*/

    cin >> s;
    build(0, 0, n, s);
    string t;
    while (q--) {
        char c;
        
        //c = '#';

        cin >> c;

        
        if (c == '?') {
            int i, j;
            cin >> i >> j;

            /*i = rand() % n + 1;
            j = i + rand() % (n - i + 1);*/

            fill(cur_dp, cur_dp + K + 1, INF);
            cur_dp[K] = 0;
            get(0, 0, n, i - 1, j);
            cout << cur_dp[K] << '\n';
        } else {
            int l, r;
            cin >> l >> r;
            
            /*l = rand() % n + 1;
            r = l + 1;
            t = char('a' + rand() % 26);*/

            cin >> t;
            upd(0, 0, n, l - 1, r, t);
        }
    }
    return 0;
}