#include<bits/stdc++.h>

#define ll long long 

using namespace std;

int read()
{
	int a=0,f=1,c=getchar();
	while(!isdigit(c))
	{
		if(c=='-')f=-1;
		c=getchar();
	}
	while(isdigit(c))
	{
		a=a*10+c-'0';
		c=getchar();
	}
	return a*f;
}

const int N=1e5+10;
const int P=1e9+7;
ll mod(ll x){return (x%P+P)%P;}

int n;
int a[N];
ll f[2][N],g[2][N];

int main()
{
//	freopen("1.in","r",stdin);
	
	n=read();
	for(int i=1;i<=n;++i)a[i]=read();
	
	f[0][1]=1;
	g[0][1]=a[1];
	for(int i=2;i<=n;++i)
	{
		f[0][i]=mod(f[0][i-1]+f[1][i-1]);
		f[1][i]=f[0][i-1];
		g[0][i]=mod(g[0][i-1]+g[1][i-1]+a[i]*f[0][i]);
		g[1][i]=mod(g[0][i-1]-a[i]*f[1][i]);
	}
	printf("%lld\n",mod(g[0][n]+g[1][n]));
	
	return 0;
}
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i = 0; i < n; i++)
#define rep2(i, x, n) for(int i = x; i <= n; i++)
#define rep3(i, x, n) for(int i = x; i >= n; i--)
#define each(e, v) for(auto &e: v)
#define pb push_back
#define eb emplace_back
#define all(x) x.begin(), x.end()
#define rall(x) x.rbegin(), x.rend()
#define sz(x) (int)x.size()
using ll = long long;
using pii = pair<int, int>;
using pil = pair<int, ll>;
using pli = pair<ll, int>;
using pll = pair<ll, ll>;
//const int MOD = 1000000007;
const int MOD = 998244353;
const int inf = (1<<30)-1;
const ll INF = (1LL<<60)-1;
template<typename T> bool chmax(T &x, const T &y) {return (x < y)? (x = y, true) : false;};
template<typename T> bool chmin(T &x, const T &y) {return (x > y)? (x = y, true) : false;};

struct io_setup{
    io_setup(){
        ios_base::sync_with_stdio(false);
        cin.tie(NULL);
        cout << fixed << setprecision(15);
    }
} io_setup;

template<int mod>
struct Mod_Int{
    int x;

    Mod_Int() : x(0) {}

    Mod_Int(ll y) : x(y >= 0 ? y % mod : (mod - (-y) % mod) % mod) {}

    Mod_Int &operator += (const Mod_Int &p){
        if((x += p.x) >= mod) x -= mod;
        return *this;
    }

    Mod_Int &operator -= (const Mod_Int &p){
        if((x += mod - p.x) >= mod) x -= mod;
        return *this;
    }

    Mod_Int &operator *= (const Mod_Int &p){
        x = (int) (1LL * x * p.x % mod);
        return *this;
    }

    Mod_Int &operator /= (const Mod_Int &p){
        *this *= p.inverse();
        return *this;
    }

    Mod_Int &operator ++ () {return *this += Mod_Int(1);}

    Mod_Int operator ++ (int){
        Mod_Int tmp = *this;
        ++*this;
        return tmp;
    }

    Mod_Int &operator -- () {return *this -= Mod_Int(1);}

    Mod_Int operator -- (int){
        Mod_Int tmp = *this;
        --*this;
        return tmp;
    }

    Mod_Int operator - () const {return Mod_Int(-x);}

    Mod_Int operator + (const Mod_Int &p) const {return Mod_Int(*this) += p;}

    Mod_Int operator - (const Mod_Int &p) const {return Mod_Int(*this) -= p;}

    Mod_Int operator * (const Mod_Int &p) const {return Mod_Int(*this) *= p;}

    Mod_Int operator / (const Mod_Int &p) const {return Mod_Int(*this) /= p;}

    bool operator == (const Mod_Int &p) const {return x == p.x;}

    bool operator != (const Mod_Int &p) const {return x != p.x;}

    Mod_Int inverse() const {
        assert(*this != Mod_Int(0));
        return pow(mod-2);
    }

    Mod_Int pow(ll k) const{
        Mod_Int now = *this, ret = 1;
        for(; k; k >>= 1, now *= now){
            if(k&1) ret *= now;
        }
        return ret;
    }

    friend ostream &operator << (ostream &os, const Mod_Int &p){
        return os << p.x;
    }

    friend istream &operator >> (istream &is, Mod_Int &p){
        ll a;
        is >> a;
        p = Mod_Int<mod>(a);
        return is;
    }
};

using mint = Mod_Int<MOD>;

int main(){
    int H, W, K;
    cin >> H >> W >> K;

    vector<vector<mint>> dp(H, vector<mint>(W, 0));
    vector<vector<char>> a(H, vector<char>(W, '0'));

    rep(i, K){
        int x, y;
        char c;
        cin >> x >> y >> c; x--, y--;
        a[x][y] = c;
    }

    dp[0][0] = 1;
    mint p = mint(2)/mint(3);

    rep(i, H){
        rep(j, W){
            if((i < H-1 || j < W-1) && a[i][j] == '0') dp[i][j] *= p;
            if(a[i][j] != 'R' && i+1 < H){
                dp[i+1][j] += dp[i][j];
            }
            if(a[i][j] != 'D' && j+1 < W){
                dp[i][j+1] += dp[i][j];
            }
        }
    }

    mint ans = dp[H-1][W-1];
    ans *= mint(3).pow(H*W-K);
    cout << ans << '\n';
}