#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<int, int>; using Pll = pair<ll, ll>;
using vi = vector<int>; using vvi = vector<vector<int>>; using vvvi = vector<vvi>;
using vl = vector<ll>; using vvl = vector<vector<ll>>; using vvvl = vector<vvl>;
using vb = vector<bool>; using vvb = vector<vector<bool>>;
using vp = vector<P>; using vpll = vector<Pll>; using vvp = vector<vector<P>>;
using vs = vector<string>;
#define rep(i, s, n) for (long long i = (s); i < (long long)(n); i++)
#define drep(i, s, n) for (long long i = (s); i >= (long long)(n); i--)
template <typename T> bool chmax(T& a, const T& b) { if (a < b) { a = b; return true; } return false; }
template <typename T> bool chmin(T& a, const T& b) { if (a > b) { a = b; return true; } return false; }
const int INF = 1001001001;
const ll LLINF = 1e18;

// Mod int
using ull = unsigned long long; using uint = unsigned;
#define pb push_back
const uint mod = 998244353;
//const uint mod = 1000000007;
struct mint {
    uint x;
    mint() : x(0) {}
    mint(ll x) :x((x% mod + mod) % mod) {}
    mint operator-() const { return mint(0) - *this; }
    mint operator~() const { return mint(1) / *this; }
    mint& operator+=(const mint& a) { if ((x += a.x) >= mod) x -= mod; return *this; }
    mint& operator-=(const mint& a) { if ((x += mod - a.x) >= mod) x -= mod; return *this; }
    mint& operator*=(const mint& a) { x = (ull)x * a.x % mod; return *this; }
    mint& operator/=(const mint& a) { x = (ull)x * a.pow(mod - 2).x % mod; return *this; }
    mint operator+(const mint& a) const { return mint(*this) += a; }
    mint operator-(const mint& a) const { return mint(*this) -= a; }
    mint operator*(const mint& a) const { return mint(*this) *= a; }
    mint operator/(const mint& a) const { return mint(*this) /= a; }
    mint pow(ll t) const {
        mint res = 1; for (mint p = x; t; p *= p, t >>= 1) if (t & 1) res *= p; return res;
    }
    mint ppow(ll t) const { int p = mod - 1; return pow((t % p + p) % p); }
    bool operator<(const mint& a) const { return x < a.x; }
    bool operator==(const mint& a) const { return x == a.x; }
    bool operator!=(const mint& a) const { return x != a.x; }
};
mint ex(mint x, ll t) { return x.pow(t); }
istream& operator>>(istream& i, mint& a) { i >> a.x; return i; }
//*
ostream& operator<<(ostream& o, const mint& a) { o << a.x; return o; }
using vm = vector<mint>;
using vvm = vector<vm>;
using vvvm = vector<vvm>;
struct modinv {
    int n; vm d;
    modinv() : n(2), d({ 0,1 }) {}
    mint operator()(int i) { while (n <= i) d.pb(-d[mod % n] * (mod / n)), ++n; return d[i]; }
    mint operator[](int i) const { return d[i]; }
} invs;
struct modfact {
    int n; vm d;
    modfact() : n(2), d({ 1,1 }) {}
    mint operator()(int i) { while (n <= i) d.pb(d.back() * n), ++n; return d[i]; }
    mint operator[](int i) const { return d[i]; }
} facs;
struct modfactinv {
    int n; vm d;
    modfactinv() : n(2), d({ 1,1 }) {}
    mint operator()(int i) { while (n <= i) d.pb(d.back() * invs(n)), ++n; return d[i]; }
    mint operator[](int i) const { return d[i]; }
} ifacs;
mint comb(int a, int b) {
    if (a < b || b < 0) return 0;
    return facs(a) * ifacs(b) * ifacs(a - b);
}
mint perm(int a, int b) {
    if (a < b || b < 0) return 0;
    return  facs(a) * ifacs(a - b);
}
//

int main()
{
    int n; string s;
    cin >> n >> s;

    vvi ch(n, vi(26, 1));
    
    rep(i, 0, n) if(s[i] != '?')
    {
        if (i - 1 >= 0) ch[i - 1][s[i] - 'a'] &= 0;
        if (i - 2 >= 0) ch[i - 2][s[i] - 'a'] &= 0;
        if (i + 1 < n) ch[i + 1][s[i] - 'a'] &= 0;
        if (i + 2 < n) ch[i + 2][s[i] - 'a'] &= 0;
        rep(j, 0, 26)
        {
            if (j != s[i] - 'a') ch[i][j] &= 0;
        }
    }

    vvm dp(26, vm(26, 0));
   
    rep(i, 0, 26) rep(j, 0, 26)
    {
        if (i == j) continue;
        if (!ch[0][i] || !ch[1][j]) continue;
        dp[i][j] = 1;
    }

    rep(i, 2, n)
    {
        vvm dq(26, vm(26, 0));
        rep(j, 0, 26) rep(k, 0, 26)
        {
            if (j == k) continue;
            if (!ch[i][k]) continue;

            rep(x, 0, 26)
            {
                if (x == k) continue;
                dq[j][k] += dp[x][j];
            }
        }
        swap(dp, dq);
    }

    mint ans = 0;
    rep(i, 0, 26) rep(j, 0, 26) ans += dp[i][j];
    cout << ans;
}