#include <bits/stdc++.h>
using namespace std;

#ifdef CKISEKI
#define safe cerr<<__PRETTY_FUNCTION__<<" line "<<__LINE__<<" safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
template <typename ...T>
void debug_(const char *s, T ... a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I>
void orange_(const char *s, I L, I R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) safe
#define orange(...) safe
#endif

struct Node {
    int l, r;
    int cnt;
    Node() : l(0), r(0), cnt(0) {}
};

const int maxn = 1000025, lg = 21;
Node pool[maxn * lg * 3];
int ptr = 1;

const int mod = 998244353;
int modadd(int a, int b) {
    return a + b >= mod ? a + b - mod : a + b;
}

int query(int ql, int qr, int o, int l, int r) {
    if (!o || qr <= l || ql >= r)
        return 0;
    if (ql <= l && r <= qr)
        return pool[o].cnt;
    int m = (l + r) / 2;
    return modadd(query(ql, qr, pool[o].l, l, m), query(ql, qr, pool[o].r, m, r));
}

int add(int pos, int val, int o, int l, int r) {
    if (!o) {
        o = ptr++;
    }
    if (r - l == 1) {
        pool[o].cnt = modadd(pool[o].cnt, val);
        return o;
    }
    int m = (l + r) / 2;
    if (pos < m) {
        pool[o].l = add(pos, val, pool[o].l, l, m);
    } else {
        pool[o].r = add(pos, val, pool[o].r, m, r);
    }
    pool[o].cnt = modadd(pool[pool[o].l].cnt, pool[pool[o].r].cnt);
    return o;
}

//void dump(Node *o, int l, int r) {
//    if (r - l == 1) {
//        cerr << (o ? o->cnt : 0) << ' ';
//        return;
//    }
//    int m = (l + r) / 2;
//    dump(o ? o->l : nullptr, l, m);
//    dump(o ? o->r : nullptr, m, r);
//}

int main() {
    cin.tie(nullptr) -> sync_with_stdio(false);
    string S;
    cin >> S;
    int ch[256] = {};
    ch['I'] = 0;
    ch['C'] = 1;
    ch['P'] = 2;

    vector<array<int,4>> P;
    const int n = (int)S.size();

    P.push_back({0, 0, 0});

    for (int i = 0; i < n; i++) {
        int c = ch[S[i]];
        auto t = P.back();
        t[c] += 1;
        P.push_back(t);
    }

    vector<int> root[3];
    for (int j = 0; j < 3; j++) {
        root[j].resize(n * 2 + 1);
    }
    const int offset = n;

    vector<int> dp(n + 1);
    dp[0] = 1;
    for (int i = 0; i <= n; i++) {
        const auto &a = P[i];
        for (int j = 0; j < 3; j++) {
            int s = a[j] - a[(j+2)%3];
            int x = a[j] - a[(j+1)%3];
            int Q = query(x + offset + 1, n * 2 + 1, root[j][s + offset], 0, n * 2 + 1);

            dp[i] = modadd(dp[i], Q);
        }
        debug(dp[i]);
        for (int j = 0; j < 3; j++) {
            int s = a[j] - a[(j+2)%3];
            int x = a[j] - a[(j+1)%3];
            root[j][s + offset] = add(x + offset, dp[i], root[j][s + offset], 0, n * 2 + 1);

            // debug(s, x, j, i);
            // dump(root[j][s + offset], 0, n * 2 + 1);
            // cerr << endl;
        }
    }
    cout << dp[n] << '\n';
}