#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;

struct Node {
    int ls{};
    int rs{};
    int pos{};
    int pri{};
    i64 sum{}, val{};
};

const int kN = 6e6;
Node no[kN];
int top = 2;
mt19937 rng(3232);

int newNode(i64 val, i64 pos) {
    no[top] = Node();
    no[top].val = no[top].sum = val;
    no[top].pos = pos;
    no[top].pri = rng();
    return top++;
}

void pull(int p) {
    no[p].sum = no[p].val;
    if (no[p].ls) no[p].sum += no[no[p].ls].sum;
    if (no[p].rs) no[p].sum += no[no[p].rs].sum;
    no[p].sum %= mod;
}

int Merge(int a, int b) {
    if (a == 0 or b == 0) return a + b;
    if (no[a].pri < no[b].pri) {
        no[a].rs = Merge(no[a].rs, b);
        pull(a);
        return a;
    } else {
        no[b].ls = Merge(a, no[b].ls);
        pull(b);
        return b;
    }
}

void Split(int p, int &a, int &b, int k) {
    if (!p) {
        a = b = 0;
        return;
    }

    if (no[p].pos < k) {
        a = p;
        Split(no[p].rs, no[a].rs, b, k);
        pull(a);
    } else {
        b = p;
        Split(no[p].ls, a, no[b].ls, k);
        pull(b);
    }
}

constexpr int off = 1e6 + 5;
int root[3][off * 2]{};

void insert(int &r, int p) {
    int L, R;
    Split(r, L, R, no[p].pos);
    r = Merge(Merge(L, p), R);
}

i64 query(int &r, int pos) {
    int L, R;
    Split(r, L, R, pos);
    i64 ans = L ? no[L].sum : 0;
    r = Merge(L, R);
    return ans;
}

void show(int p) {
    if (!p) return;
    if (no[p].ls) show(no[p].ls);
    debug(p, no[p].sum, no[p].pos);
    if (no[p].rs) show(no[p].rs);
}

void solve() {
    string S;
    cin >> S;

    const int n = S.size();
    
    array<string, 3> T{"PCI", "CIP", "ICP"};
    
    int M[3]{off, off, off};
    int C[3]{off, off, off};
    
    for (int i : {0, 1, 2})
        insert(root[i][C[i]], newNode(1, M[i])); // val pos
    
    vector<i64> dp(n);
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < 3; j++) {
            if (S[i] == T[j][0]) {
                M[j]++;
            } else {
                C[j] += (S[i] == T[j][1] ? 1 : -1);
                M[j] -= (S[i] == T[j][1] ? 1 : 0);
            }
        }
        
        for (int j = 0; j < 3; j++) {
            dp[i] += query(root[j][C[j]], M[j]);
        }
        dp[i] %= mod;
        
        for (int j = 0; j < 3; j++) {
            insert(root[j][C[j]], newNode(dp[i], M[j]));
        }
    }

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

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