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

typedef long long ll;

// Constants
const int MOD = 998244353;

// Structure to store mask_prev and mask_pc for each row assignment
struct RowAssignment {
    int mask_prev; // Mask for 'I C' positions
    int mask_pc;   // Mask for 'P C' positions
};

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    
    int n, m;
    cin >> n >> m;
    vector<string> grid(n);
    for(auto &s : grid) cin >> s;
    
    // Mapping characters to numerical values
    // 'C' = 0, 'I' = 1, 'P' = 2
    unordered_map<char, int> char_map = { {'C', 0}, {'I', 1}, {'P', 2} };
    
    // Precompute all possible row assignments
    // Total states per row: 3^m
    int total_states = pow(3, m);
    vector<RowAssignment> assignments(total_states);
    
    for(int s = 0; s < total_states; s++){
        int tmp = s;
        int mask_prev = 0;
        int mask_pc = 0;
        for(int j = 0; j < m; j++){
            int val = tmp % 3;
            tmp /=3;
            // Compute mask_prev: positions where 'I' followed by 'C'
            if(j < m-1){
                int next_val = tmp % 3;
                if(val == 1 && next_val == 0){
                    mask_prev |= (1 << j);
                }
            }
            // Compute mask_pc: positions where 'P' followed by 'C'
            if(j < m-1){
                int next_val = tmp % 3;
                if(val == 2 && next_val == 0){
                    mask_pc |= (1 << j);
                }
            }
        }
        assignments[s].mask_prev = mask_prev;
        assignments[s].mask_pc = mask_pc;
    }
    
    // Initialize DP
    // dp_prev[state] represents the number of ways to reach a given state
    // where state is the mask of 'I C' positions in the previous row
    vector<ll> dp_prev(128, 0); // 7-bit masks for m=8
    for(int s = 0; s < total_states; s++){
        // Only consider valid row assignments based on the grid
        bool valid = true;
        int tmp = s;
        for(int j = 0; j < m; j++){
            if(grid[0][j] != '?'){
                if(char_map.find(grid[0][j]) == char_map.end() || char_map[grid[0][j]] != (tmp % 3)){
                    valid = false;
                    break;
                }
            }
            tmp /=3;
        }
        if(valid){
            dp_prev[assignments[s].mask_prev]++;
            dp_prev[assignments[s].mask_prev] %= MOD;
        }
    }
    
    // Iterate through each row and update DP
    for(int r =1; r < n; r++){
        vector<ll> dp_curr(128, 0);
        for(int p =0; p < 128; p++){
            if(dp_prev[p]==0) continue;
            for(int s =0; s < total_states; s++){
                // Check if current row assignment is valid based on the grid
                bool valid = true;
                int tmp = s;
                for(int j =0; j < m; j++){
                    if(grid[r][j] != '?'){
                        if(char_map.find(grid[r][j]) == char_map.end() || char_map[grid[r][j]] != (tmp %3)){
                            valid = false;
                            break;
                        }
                    }
                    tmp /=3;
                }
                if(!valid) continue;
                
                // Check forbidden patterns
                // If previous row had 'I C' at position j, current row cannot have 'P C' at the same position
                if( (p & assignments[s].mask_pc) !=0 ) continue;
                
                // Update dp_curr with the new mask_prev
                dp_curr[assignments[s].mask_prev] += dp_prev[p];
                if(dp_curr[assignments[s].mask_prev] >= MOD){
                    dp_curr[assignments[s].mask_prev] -= MOD;
                }
            }
        }
        dp_prev = move(dp_curr);
    }
    
    // Calculate A: Number of assignments without any forbidden pattern
    ll A =0;
    for(int p=0; p <128; p++) {
        A = (A + dp_prev[p]) % MOD;
    }
    
    // Calculate T = 3^(k) mod MOD, where k is the number of '?'
    int k=0;
    for(int r=0; r <n; r++) {
        for(int j=0; j <m; j++) {
            if(grid[r][j] == '?') k++;
        }
    }
    
    // Fast exponentiation to compute 3^k mod MOD
    auto powmod_func = [&](ll base_val, ll exp, ll mod_val) -> ll {
        ll res =1;
        base_val %= mod_val;
        while(exp >0){
            if(exp &1LL){
                res = res * base_val % mod_val;
            }
            base_val = base_val * base_val % mod_val;
            exp >>=1LL;
        }
        return res;
    };
    ll T = powmod_func(3, k, MOD);
    
    // The answer is (T - A) mod MOD
    ll answer = (T - A + MOD) % MOD;
    cout << answer;
}