// 解き直し.
// https://atcoder.jp/contests/keyence2021/editorial/564
// C++(GCC 9.2.1)
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
#define repex(i, a, b, c) for(int i = a; i < b; i += c)
#define repx(i, a, b) repex(i, a, b, 1)
#define rep(i, n) repx(i, 0, n)
#define repr(i, a, b) for(int i = a; i >= b; i--)
const LL MOD = 998244353;
const LL DIV3 = 332748118;
const int MAX = 5050;
char board[MAX][MAX];
LL dp[MAX][MAX];

// Fermat's little theorem から, 大きな冪乗の計算を行う.
// @param a: べき乗したい正整数.
// @param b: 指数.
// @return:  べき乗した計算結果(mod版).
LL mPow(LL a, LL b){
    LL t = 1;
    while(b){
        if(b & 1) t = (t * a) % MOD;
        a = a * a % MOD;
        b >>= 1;
    }
    return t % MOD;
}

int main(){
    
    // 1. 入力情報.
    int H, W, K;
    scanf("%d %d %d", &H, &W, &K);
    rep(h, MAX) rep(w, MAX) board[h][w] = '.';
    rep(i, K){
        int h, w;
        char c[11];
        scanf("%d %d %s", &h, &w, c);
        h--, w--;
        board[h][w] = c[0];
    }
    
    // 2. dp更新.
    dp[0][0] = 1;
    rep(h, H){
        rep(w, W){
            // 2-1. 開始地点は, Skip.
            if(h ==0 && w == 0) continue;
            
            // 2-2. 行方向更新.
            if(h){
                // マス目(h - 1, w) の 値.
                char op = board[h - 1][w];
                LL cur = dp[h - 1][w];
                
                // マス目(h - 1, w) が, 空欄 の 場合.
                if(op == '.'){
                    cur *= 2LL;
                    cur %= MOD;
                    cur *= DIV3;
                    cur %= MOD;
                }
                
                // マス目(h - 1, w) が, 'X', 'D' の 場合(何もしない).
                // if(op == 'X' || op == 'D'){}
                
                // マス目(h - 1, w) が, 'R' の 場合.
                if(op == 'R') cur = 0;
                
                // マス目(h, w) を 更新.
                dp[h][w] += cur;
                dp[h][w] %= MOD;
            }
            
            // 2-3. 列方向更新.
            if(w){
                // マス目(h, w - 1) の 値.
                char op = board[h][w - 1];
                LL cur = dp[h][w - 1];
                
                // マス目(h, w - 1) が, 空欄 の 場合.
                if(op == '.'){
                    cur *= 2LL;
                    cur %= MOD;
                    cur *= DIV3;
                    cur %= MOD;
                }
                
                // マス目(h, w - 1) が, 'X', 'R' の 場合(何もしない).
                // if(op == 'X' || op == 'R'){}
                
                // マス目(h, w - 1) が, 'D' の 場合.
                if(op == 'D') cur = 0;
                
                // マス目(h, w) を 更新.
                dp[h][w] += cur;
                dp[h][w] %= MOD;
            }
        }
    }
    
    // 3. 3 の (H * W - K)乗.
    LL ans = dp[H - 1][W - 1];
    ans *= mPow(3LL, (LL)(H * W - K));
    ans %= MOD;
    
    // 4. 出力.
    printf("%lld\n", ans);
    return 0;
    
}
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
constexpr int Inf = 1000000030;
constexpr ll INF= 2000000000000000000;
constexpr ll MOD = 998244353;
const double PI = 3.1415926535897;
typedef pair<int,int> P;
typedef pair<int,P> PP;

template<class T> inline bool chmax(T &a, T b) {
    if (a < b) {
        a = b;
        return 1;
    }
    return 0;
}

template<class T> inline bool chmin(T &a, T b) {
    if (a > b) {
        a = b;
        return 1;
    }
    return 0;
}

ll mod(ll val, ll M) {
    val = val % M;
    if(val < 0) {
        val += M;
    }
    return val;
}

template<typename T>
T RS(T N, T P, T M){
    if(P == 0) {
        return 1;
    }
    if(P < 0) {
        return 0;
    }
    if(P % 2 == 0){
        ll t = RS(N, P/2, M);
        if(M == -1) return t * t;
        return t * t % M;
    }
    if(M == -1) {
        return N * RS(N,P - 1,M);
    }
    return N * RS(N, P-1, M) % M;
}

ll dp[5050][5050];

int main() {
    int H,W,K;
    cin >> H >> W >> K;
    vector<vector<int>> vec(H,vector<int>(W));
    for(int i = 0;i < K;i++) {
        int h,w;
        char c;
        cin >> h >> w >> c;
        h--;
        w--;
        if(c == 'R') {
            vec.at(h).at(w) = 1;
        }
        else if(c == 'D') {
            vec.at(h).at(w) = 2;
        }
        else {
            vec.at(h).at(w) = 3;
        }
    }
    ll inv = RS((ll)3,MOD - 2,MOD);
    for(int i = 0;i < 5050;i++) {
        for(int j = 0;j < 5050;j++) {
            dp[i][j] = 0;
        }
    }
    dp[0][0] = RS((ll)3,(ll)H * W - K,MOD);
    for(int i = 0;i < H;i++) {
        for(int j = 0;j < W;j++) {
            if(vec.at(i).at(j) == 1) {
                dp[i][j + 1] += dp[i][j];
            }
            else if(vec.at(i).at(j) == 2) {
                dp[i + 1][j] += dp[i][j];
            }
            else if(vec.at(i).at(j) == 3) {
                dp[i][j + 1] += dp[i][j];
                dp[i + 1][j] += dp[i][j];
            }
            else {
                dp[i][j + 1] += dp[i][j] * 2 * inv % MOD;
                dp[i + 1][j] += dp[i][j] * 2 * inv % MOD;
            }
            dp[i][j + 1] %= MOD;
            dp[i + 1][j] %= MOD;
        }
    }
    cout << dp[H - 1][W - 1] << endl;
    
}