#include <bits/stdc++.h>

using namespace std;

/*
template <ranges::range T,
          class = enable_if_t<!is_convertible_v<T, string_view>>>
istream &operator>>(istream &s, T &&v) {
    for (auto &&x : v)
        s >> x;
    return s;
}
template <ranges::range T,
          class = enable_if_t<!is_convertible_v<T, string_view>>>
ostream &operator<<(ostream &s, T &&v) {
    for (auto &&x : v)
        s << x << ' ';
    return s;
}
*/

#ifdef LOCAL
template <class... T> void dbg(T... x) {
    char e{};
    ((cerr << e << x, e = ' '), ...);
}
#define debug(x...) dbg(#x, '=', x, '\n')
#else
#define debug(...) ((void)0)
#endif

#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second

template <class T> inline constexpr T inf = numeric_limits<T>::max() / 2;
template <class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template <class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;

constexpr i64 mod = 998244353;
 
void solve() {
    string S;
    cin >> S;

    const int n = S.size();
    vector pre(3, vector<int>(n + 1));
    for (int p = 0; char c : {'I', 'C', 'P'}) {
        for (int i = 1; i <= n; i++) {
            pre[p][i] = (S[i - 1] == c) + pre[p][i - 1];
        }
        p++;
    }

    vector<pair<int, bool>> ord(n + 1);

    vector<i64> dp(n + 1);
    dp[0] = 1;
    
    auto DC = [&](auto self, int l, int r) -> void {
        if (r - l == 1) return;

        int mid = (l + r) / 2;

        auto work = [&](int p) -> void {
            for (int i = l; i < r; i++) {
                ord[i] = {i, (i < mid)};
            }

            auto get = [&](int x) {
                return pre[p][x] - pre[(p + 1) % 3][x];
            };
            auto get2 = [&](int x) {
                return pre[(p + 1) % 3][x] - pre[(p + 2) % 3][x];
            };
            sort(ord.begin() + l, ord.begin() + r, 
                [&](auto a, auto b) {
                    return pair{get(a.ff), a.ss} < pair{get(b.ff), b.ss};
                });

            map<int, i64> sum;
            for (int i = l; i < r; i++) {
                auto [pos, mode] = ord[i];
                if (mode == 0) {
                    (dp[pos] += sum[get2(pos)]) %= mod;
                } else {
                    (sum[get2(pos)] += dp[pos]) %= mod;
                }
            }
        };

        self(self, l, mid);
        for (int p : {0, 1, 2}) {
            work(p);
        }
        self(self, mid, r);
    };

    DC(DC, 0, n + 1);

    cout << dp[n] << '\n';
    
}

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}