#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 {
    Node *ls{}, *rs{};
    int pri{};
    int pos{};
    i64 sum{}, val{};
};

const int kN = 6e6;
// Node node[kN];
int top = 0;
mt19937 rng(111);

Node *newNode(i64 pos, i64 val) {
    //node[top] = Node();
    //Node *p = // &node[top++];
    Node *p = new Node();
    p->pri = rng();
    p->pos = pos;
    p->val = val;
    p->sum = val;
    return p;
}

void pull(Node *p) {
    p->sum = p->val;
    if (p->ls) p->sum += p->ls->sum;
    if (p->rs) p->sum += p->rs->sum;
    p->sum %= mod;
}

Node *Merge(Node *a, Node *b) {
    if (!a or !b) return a ? a : b;
    if (a->pri < b->pri) {
        a->rs = Merge(a->rs, b);
        pull(a);
        return a;
    } else {
        b->ls = Merge(a, b->ls);
        pull(b);
        return b;
    }
}

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

    if (p->pos < k) {
        a = p;
        Split(p->rs, a->rs, b, k);
        pull(a);
    } else {
        b = p;
        Split(p->ls, a, b->ls, k);
        pull(b);
    }
}

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

void insert(Node *&r, Node *p) {
    Node *L, *R;
    Split(r, L, R, p->pos);
    r = Merge(Merge(L, p), R);
}

i64 query(Node *&r, int pos) {
    Node *L, *R;
    Split(r, L, R, pos);
    i64 ans = L ? L->sum : 0;
    r = Merge(L, R);
    return ans;
}

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(M[i], 1)); // pos val
    
    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(M[j], dp[i]));
        }
    }

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