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

using ll = long long;
using ld = long double;

#define pb push_back
#define si(x) int(x.size())
#define all(x) x.begin(), x.end()
#define fi first
#define se second

const int N = 50000;
const int C = N + 1;
const int MOD = 998244353;

int add(int a, int b){ a += b; if(a >= MOD) a -= MOD; return a; }
int mul(int a, int b){ return (1LL*a*b)%MOD; }
int sub(int a, int b){ return add(a, MOD - b); }

int pw(int a, int b){
    if(b == 0) return 1;
    int res = pw(a, b/2);
    res = mul(res, res);
    if(b%2) res = mul(res, a);
    return res;
}

const int root = pw(3, 119);
const int root_1 = pw(root, MOD - 2);
const int root_pw = 1 << 23;
 
void fft(vector<int> &a, bool invert) {
    int n = a.size();
 
    for (int i = 1, j = 0; i < n; i++) {
        int bit = n >> 1;
        for (; j & bit; bit >>= 1)
            j ^= bit;
        j ^= bit;
 
        if (i < j)
            swap(a[i], a[j]);
    }
 
    for (int len = 2; len <= n; len <<= 1) {
        int wlen = invert ? root_1 : root;
        for (int i = len; i < root_pw; i <<= 1)
            wlen = (int)(1LL * wlen * wlen % MOD);
 
        for (int i = 0; i < n; i += len) {
            int w = 1;
            for (int j = 0; j < len / 2; j++) {
                int u = a[i+j], v = (int)(1LL * a[i+j+len/2] * w % MOD);
                a[i+j] = u + v < MOD ? u + v : u + v - MOD;
                a[i+j+len/2] = u - v >= 0 ? u - v : u - v + MOD;
                w = (int)(1LL * w * wlen % MOD);
            }
        }
    }
 
    if (invert) {
        int n_1 = pw(n, MOD - 2);
        for (int & x : a)
            x = mul(x, n_1);
    }
}
 
vector <int> multiply(vector <int> va, vector <int> vb){
    int ns = si(va) + si(vb);
    int j = 1;
    while(j < ns) j *= 2;
    while(si(va) < j) va.pb(0);
    while(si(vb) < j) vb.pb(0);
    fft(va, 0);
    fft(vb, 0);
    for(int i=0; i<si(va); i++){
        va[i] = mul(va[i], vb[i]);
    }
    fft(va, 1);
    return va;
}

string arc = " ";
string pt = " ";

int ways_arc(int i, int j){
    if(arc[i] == '?') return 1;
    if(j == 0) return (arc[i] == 'Y');
    return arc[i] == 'P';
}

int ways_pt(int i, int j){
    if(pt[i] == '?') return 1;
    if(j == 0) return (pt[i] == 'R');
    return pt[i] == 'B';
}

vector <int> dp[4*N+5][2][2];

void calc(int node, int l, int r){
    if(l == r){
        for(int fs=0; fs<=1; fs++){
            for(int ls=0; ls<=1; ls++){
                if(fs != ls) dp[node][fs][ls].pb(0);
                else dp[node][fs][ls].pb(ways_arc(l, fs));
            }
        }
        return;
    }
    int mid = (l+r)/2;
    int d = r - l;
    for(int f=0; f<=1; f++){
        for(int l=0; l<=1; l++){
            for(int x=-d; x<=d; x++){
                dp[node][f][l].pb(0);
            }
        }
    }
    calc(node*2, l, mid);
    calc(node*2+1, mid+1, r);
    for(int h=0; h<=1; h++){
        if(!ways_pt(mid, h)) continue;
        for(int f1=0; f1<=1; f1++){
            for(int l2=0; l2<=1; l2++){
                for(int f2=0; f2<=1; f2++){
                    int d1 = mid - l + 1;
                    vector <int> vlv;
                    for(int x=-d1; x<=d1; x++){
                        vlv.pb(0);
                    }
                    for(int l1=0; l1<=1; l1++){
                        for(int x=-d1+1; x<=d1-1; x++){
                            int sm = (l1 == f2 ? 0 : 1)*(abs(x)%2 ? -1 : 1)*(h ? -1 : 1);
                            vlv[x+d1+sm] = add(vlv[x+d1+sm], dp[node*2][f1][l1][x+d1-1]);
                        }
                    }
                    vector <int> p, np;
                    for(int x=-d1; x<=d1; x++){
                        int v = (abs(x)%2 ? -1 : 1);
                        p.pb(0);
                        np.pb(0);
                        if(v == 1) p.back() = vlv[x+d1];
                        else np.back() = vlv[x+d1];
                    }
                    vector <int> v1 = multiply(p, dp[node*2+1][f2][l2]);
                    v1.pb(0);
                    vector <int> r2 = dp[node*2+1][f2][l2];
                    reverse(all(r2));
                    vector <int> v2 = multiply(np, r2);
                    v2.pb(0);
                    for(int x=-d; x<=d; x++){
                        dp[node][f1][l2][x+d] = add(dp[node][f1][l2][x+d], add(v1[x+d], v2[x+d]));
                    }
                }
            }
        }
    }
}

int main(){
    ios_base::sync_with_stdio(false), cin.tie(0);
    cout.precision(10);
    cout << fixed;

    int n;
    cin >> n;
    string s;
    cin >> s;
    for(int i=0; i<si(s); i+=2){
        arc += s[i];
        pt += s[i+1];
    }
    calc(1, 1, n);
    int res = 0;
    for(int fs=0; fs<=1; fs++){
        for(int ls=0; ls<=1; ls++){
            int c = n - 1;
            if(fs == ls){
                for(int h=0; h<=1; h++){
                    int x = mul(dp[1][fs][ls][c], ways_pt(n, h));
                    res = add(res, x);
                }
            }
            else{
                for(int h=0; h<=1; h++){
                    int sm = -1*(h ? -1 : 1);
                    int x = mul(ways_pt(n, h), dp[1][fs][ls][c-sm]);
                    res = add(res, x);
                }
            }
        }
    }
    cout << res << "\n";
    return 0;
}