#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>

#ifdef LOCAL
#include "../debug/debug.h"
#else
#define debug(...)
#define debugArr(...)
#endif

using namespace std;
using namespace __gnu_pbds;

using ll = long long;
using db = long double;
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vvi = vector<vi>;

#define mp make_pair
#define eb emplace_back
#define pb push_back
#define x first
#define y second
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(), (x).rend() 
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define ft front()
#define bk back()
#define rsz resize
#define ins insert
#define each(a,x) for(auto&a:x)

template<class T> bool ckmin(T& a, T b) { return b<a?a=b,1:0; }
template<class T> bool ckmax(T& a, T b) { return b>a?a=b,1:0; }
template<class T> int lwb(vector<T>& a, const T& b) { return int(lower_bound(all(a),b)-bg(a)); }
template<class T> int upb(vector<T>& a, const T& b) { return int(upper_bound(all(a),b)-bg(a)); }
template<class T> void remdup(vector<T>& v) { sort(all(v)); v.erase(unique(all(v)),end(v)); }

constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bitlog(int x) { return x == 0 ? 0 : 31 - __builtin_clz(x); }
constexpr int pct(ll x) { return __builtin_popcountll(x); }
constexpr int bitlog(ll x) { return x == 0 ? 0 : 63 - __builtin_clzll(x); }

constexpr ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }  // divide a by b rounded up
constexpr ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }  // divide a by b rounded down
constexpr int cdiv(int a, int b) { return a / b + ((a ^ b) > 0 && a % b); }  // divide a by b rounded down
constexpr int fdiv(int a, int b) { return a / b - ((a ^ b) < 0 && a % b); }  // divide a by b rounded down

const pi MOVES[] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};

#ifdef LOCAL
mt19937_64 rng(0xabadbeef);
#else
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif

constexpr int FACTORIAL[] = {1, 1, 2, 6, 24, 120, 720, 5040};

vi decode_perm(int n, int a) {
	vi el(n), b; iota(all(el),0);
	rep(i,0,n) {
		int z = a%sz(el);
		b.pb(el[z]); a /= sz(el);
		swap(el[z],el.bk); el.pop_back();
	}
	return b;
}

int encode_perm(vi b) {
	int n = sz(b), a = 0, mul = 1;
	vi pos(n); iota(all(pos),0); vi el = pos;
	rep(i,0,n) {
		int z = pos[b[i]]; a += mul*z; mul *= sz(el);
		swap(pos[el[z]],pos[el.bk]); 
		swap(el[z],el.bk); el.pop_back();
	}
    return a;
}

template <uint32_t mod>
struct LazyMontgomeryModInt {
  using mint = LazyMontgomeryModInt;
  using i32 = int32_t;
  using u32 = uint32_t;
  using u64 = uint64_t;

  static constexpr u32 get_r() {
    u32 ret = mod;
    for (i32 i = 0; i < 4; ++i) ret *= 2 - mod * ret;
    return ret;
  }

  static constexpr u32 r = get_r();
  static constexpr u32 n2 = -u64(mod) % mod;
  static_assert(mod < (1 << 30), "invalid, mod >= 2 ^ 30");
  static_assert((mod & 1) == 1, "invalid, mod % 2 == 0");
  static_assert(r * mod == 1, "this code has bugs.");

  u32 a;

  constexpr LazyMontgomeryModInt() : a(0) {}
  constexpr LazyMontgomeryModInt(const int64_t &b)
      : a(reduce(u64(b % mod + mod) * n2)){};

  static constexpr u32 reduce(const u64 &b) {
    return (b + u64(u32(b) * u32(-r)) * mod) >> 32;
  }

  constexpr mint &operator+=(const mint &b) {
    if (i32(a += b.a - 2 * mod) < 0) a += 2 * mod;
    return *this;
  }

  constexpr mint &operator-=(const mint &b) {
    if (i32(a -= b.a) < 0) a += 2 * mod;
    return *this;
  }

  constexpr mint &operator*=(const mint &b) {
    a = reduce(u64(a) * b.a);
    return *this;
  }

  constexpr mint &operator/=(const mint &b) {
    *this *= b.inverse();
    return *this;
  }

  constexpr mint operator+(const mint &b) const { return mint(*this) += b; }
  constexpr mint operator-(const mint &b) const { return mint(*this) -= b; }
  constexpr mint operator*(const mint &b) const { return mint(*this) *= b; }
  constexpr mint operator/(const mint &b) const { return mint(*this) /= b; }
  constexpr bool operator==(const mint &b) const {
    return (a >= mod ? a - mod : a) == (b.a >= mod ? b.a - mod : b.a);
  }
  constexpr bool operator!=(const mint &b) const {
    return (a >= mod ? a - mod : a) != (b.a >= mod ? b.a - mod : b.a);
  }
  constexpr mint operator-() const { return mint() - mint(*this); }
  constexpr mint operator+() const { return mint(*this); }

  constexpr mint pow(u64 n) const {
    mint ret(1), mul(*this);
    while (n > 0) {
      if (n & 1) ret *= mul;
      mul *= mul;
      n >>= 1;
    }
    return ret;
  }

  constexpr mint inverse() const {
    int x = get(), y = mod, u = 1, v = 0, t = 0, tmp = 0;
    while (y > 0) {
      t = x / y;
      x -= t * y, u -= t * v;
      tmp = x, x = y, y = tmp;
      tmp = u, u = v, v = tmp;
    }
    return mint{u};
  }

  friend ostream &operator<<(ostream &os, const mint &b) {
    return os << b.get();
  }

  friend istream &operator>>(istream &is, mint &b) {
    int64_t t;
    is >> t;
    b = LazyMontgomeryModInt<mod>(t);
    return (is);
  }

  constexpr u32 get() const {
    u32 ret = reduce(a);
    return ret >= mod ? ret - mod : ret;
  }

  static constexpr u32 get_mod() { return mod; }
};

const int MOD = 998244353;
using mi = LazyMontgomeryModInt<MOD>;

ll randr(ll l, ll r) { return uniform_int_distribution<ll>(l, r)(rng); }

template<int C>
struct Matrix {
    mi mat[C][C];

    constexpr inline Matrix() {
        rep(i,0,C) rep(j,0,C) mat[i][j] = 0;
    }

    constexpr static inline Matrix<C> identity() {
        Matrix<C> id;
        rep(i,0,C) {
            id.mat[i][i] = 1;
        }
        return id;
    }

    constexpr inline Matrix<C> operator*(const Matrix<C>& other) const {
        Matrix<C> res;
        rep(i,0,C) {
            rep(k,0,C) {
                rep(j,0,C) {
                    res.mat[i][j] += mat[i][k] * other.mat[k][j];
                }
            }
        }
        return res;
    }

    inline mi* operator[](int idx) { 
        return mat[idx];
    }
    const inline mi* operator[](int idx) const {
        return mat[idx];
    }
};

template<int C>
constexpr inline Matrix<C> get_transition_dp_1(int ch) {
    Matrix<C> res = Matrix<C>::identity();
    res[ch][ch] = 0;
    res[ch][C - 1] = 1;
    res[C - 1][ch] = -1;
    res[C - 1][C - 1] = 2;
    return res;
}

template<int C>
constexpr inline Matrix<C> cmb(const Matrix<C>& a, const Matrix<C>& b) {
    return a * b;
}

// transition dla dokładnie 1
// permutacja wejściowa -> (macierz, permutacja wyjściowa)
template<int C>
struct NodeOnes {
    static constexpr Matrix<C> ID = Matrix<C>::identity();

    bool is_identity = false;
    map<int, pair<Matrix<C>, int>> mat;
    
    void clear() {
        mat.clear();
    }

    void init_base(int ch, int perm_in) {
        vi perm = decode_perm(C, perm_in);
        Matrix<C> M = ID;
        rep(i,0,C) {
            if (perm[i] > perm[ch]) {
                M[ch][i] += 1;
                perm[i]--;
            }
        }
        perm[ch] = C - 1;
        int perm_out = encode_perm(perm);
        mat[perm_in] = make_pair(M, perm_out);
    }

    pair<const Matrix<C>&, int> get_mat(int perm_in) const {
        if (is_identity) {
            return {ID, perm_in};
        }
        auto it = mat.find(perm_in);
        assert(it != mat.end());
        return it->y;
    }

    bool has_out_perm(int perm_in) {
        if (is_identity) return true;
        return mat.count(perm_in);
    }

    int get_out_perm(int perm_in) {
        return mat[perm_in].y;
    }
};

const int N = 5e4+8;
int s[N];
int query_perm_idx;

template<class T, int C>
struct SegTree2 {
    int n;
    vector<T> seg;
    void init(int _n) {
        for (n = 1; n < _n;) n *= 2;
        seg.resize(2 * n);
        rep(i,0,2*n) seg[i].is_identity = true;
    }

    void eval(int node, int left, int right, int left_perm) {
        if (seg[node].has_out_perm(left_perm)) {
            return;
        }
        
        if (left == right) {
            seg[node].init_base(s[node - n], left_perm);
            return;
        }

        int mid = (left + right) / 2;
        eval(2 * node, left, mid, left_perm);
        auto [mat1, trans_perm] = seg[2 * node].get_mat(left_perm);
        eval(2 * node + 1, mid + 1, right, trans_perm);
        auto [mat2, right_perm] = seg[2 * node + 1].get_mat(trans_perm);
        seg[node].mat[left_perm] = make_pair(mat2 * mat1, right_perm);
    }

    void upd(int node, int left, int right, int idx, int ch, int left_perm) {
        if (left == idx && right == idx) {
            seg[node].clear();
            seg[node].is_identity = false;
            seg[node].init_base(ch, left_perm);
            return;
        }

        if (left > idx || right < idx) {
            // to tak powinno być?
            // chyba tak
            eval(node, left, right, left_perm);
            return;
        }

        seg[node].clear();
        seg[node].is_identity = false;

        int mid = (left + right) / 2;
        upd(2 * node, left, mid, idx, ch, left_perm);
        auto [mat1, trans_perm] = seg[2 * node].get_mat(left_perm);
        upd(2 * node + 1, mid + 1, right, idx, ch, trans_perm);
        auto [mat2, right_perm] = seg[2 * node + 1].get_mat(trans_perm);
        seg[node].mat[left_perm] = make_pair(mat2 * mat1, right_perm);
    }

    void upd(int idx, int ch) {
        upd(1, 0, n - 1, idx, ch, query_perm_idx);
    }

    mi qry() {
        T& t = seg[1];
        assert(t.mat.count(query_perm_idx));
        auto &[mat, _] = t.mat[query_perm_idx];
        mi res = 0;
        rep(i,0,C) {
            res += mat[i][C - 1];
        }
        return res;
    }
};

template<class T>
struct SegTree {
    const T ID = T::identity();
    int n;
    vector<T> seg;
    void init(int _n) {
        for (n = 1; n < _n;) n *= 2;
        seg.assign(2 * n, ID);
    }
    void pull(int p) { 
        seg[p] = cmb(seg[2*p],seg[2*p+1]);
    }
	void upd(int p, T val) {
		seg[p += n] = val;
        for (p /= 2; p; p /= 2) {
            pull(p);
        }
    }
	T query(int l, int r) {	// zero-indexed, inclusive
		T ra = ID;
        T rb = ID;
		for (l += n, r += n+1; l < r; l /= 2, r /= 2) {
			if (l&1) ra = cmb(ra,seg[l++]);
			if (r&1) rb = cmb(seg[--r],rb);
		}
		return cmb(ra,rb);
	}
};

int encode[6];
int distinct_chars = 0;
int n, q;
int qry_idx[N];
char qry_c[N];
int dp[N];
int last[8];

void init() {
    string S;

    cin >> n >> q;
    cin >> S;
    
    for (char c = 'a'; c <= 'f'; c++) {
        encode[c - 'a'] = -1;
    }
    for (char c : S) {
        if (encode[c - 'a'] == -1) {
            encode[c - 'a'] = distinct_chars++;
        }
    }

    rep(i,0,q) {
        cin >> qry_idx[i] >> qry_c[i];
        qry_idx[i]++;
        if (encode[qry_c[i] - 'a'] == -1) {
            encode[qry_c[i] - 'a'] = distinct_chars++;
        }
    }

    rep(i,2,n+2) {
        s[i] = encode[S[i - 2] - 'a'];
    }

    dp[0] = 0;
    dp[1] = 1;
}

template<int C>
void solve() {
    debug("solve", C);

    SegTree<Matrix<C + 1>> segAll;
    SegTree2<NodeOnes<C + 1>, C + 1> segOnes;

    vi query_perm(C + 1);
    iota(all(query_perm), 0);
    query_perm_idx = encode_perm(query_perm);

    segAll.init(n + 3);
    segOnes.init(n + 3);

    auto get_all = [&]() -> mi {
        return segAll.query(0, n + 2)[C][C];
    };

    auto get_once = [&]() -> mi {
        return segOnes.qry();
    };

    auto get_res = [&]() -> mi {
        auto total = get_all();
        auto once = get_once();
        return total - once;
    };

    rep(i,2,n+2) {
        segAll.upd(i, get_transition_dp_1<C + 1>(s[i]));
        segOnes.upd(i, s[i]);
    }

    cout << get_res() << '\n';

    rep(i,0,q) {
        s[qry_idx[i]] = encode[qry_c[i] - 'a'];
        segAll.upd(qry_idx[i], get_transition_dp_1<C + 1>(s[qry_idx[i]]));
        segOnes.upd(qry_idx[i], s[qry_idx[i]]);

        cout << get_res() << '\n';
    }
}

constexpr inline void add(int& x, const int y) {
    if ((x += y) >= MOD) x -= MOD;
}
constexpr inline void sub(int& x, const int y) {
    if ((x -= y) < 0) x += MOD;
}
constexpr inline int times2(int x) {
    return (x <<= 1) >= MOD ? x - MOD : x;
}

template<int C>
void run() {
    memset(last, 0, sizeof last);

    rep(i,2,n+2) {
        dp[i] = times2(dp[i - 1]);
        int& j = last[s[i]];
        sub(dp[i], j);
        j = dp[i - 1];
    }

    int res = dp[n + 1];

    rep(i,0,6) last[i] = 1;
    memset(dp + 2, 0, n * sizeof(int));

    rep(i,2,n+2) {
        int &k = last[s[i]];
        
        rep(j,0,C) {
            if (last[j] > k) {
                add(dp[i], dp[last[j]]);
            }
        }

        add(dp[i], dp[k]);
        k = i;
    }

    rep(i,0,C) {
        if (last[i] != 1) {
            sub(res, dp[last[i]]);
        }
    }

    sub(res, 1);
    cout << res << '\n';
}

template<int C>
void brut() {
    debug("brut", C);
    run<C>();

    rep(i,0,q) {
        s[qry_idx[i]] = encode[qry_c[i] - 'a'];
        run<C>();
    }
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);

    init();
    
    switch (distinct_chars) {
        case 1:
            solve<1>();
            break;
        case 2:
            solve<2>();
            break;
        case 3:
            solve<3>();
            break;
        case 4:
            solve<4>();
            break;
        case 5:
            solve<5>();
            break;
        case 6:
            solve<6>();
            break;
        default:
            solve<6>();
    }

    return 0;
}