#include <bits/stdc++.h>

using i64 = long long;
constexpr int P = 998244353;
constexpr i64 mod2 = (i64)P*P*8;
struct Poly {
    int l = 0;
    int r = 0;
    std::vector<int> a{0};

    int get(int x) const {
        if (x < l || x > r) {
            return 0;
        }
        return a[x - l];
    }
};

// Poly reverse(Poly p) {
//     std::swap(p.l, p.r);
//     p.l *= -1, p.r *= -1;
//     std::reverse(p.a.begin(), p.a.end());
//     return p;
// }

Poly operator*(const Poly &a, const Poly &b) {
    Poly c;
    c.l = a.l + b.l;
    c.r = a.r + b.r;
    std::vector<i64> tmp(c.r-c.l+1);
    c.a.resize(c.r - c.l + 1);
    for (int i = 0; i < a.a.size(); i++) {
        for (int j = 0; j < b.a.size(); j++) {
            tmp[i + j] += 1LL * a.a[i] * b.a[j];
            if(tmp[i+j]>=mod2)tmp[i+j]-=mod2;
        }
    }
    for(int i=0;i<c.r-c.l+1;i++) {
        c.a[i]=tmp[i]%P;
    }
    return c;
}

Poly operator+(const Poly &a, const Poly &b) {
    Poly c;
    c.l = std::min(a.l, b.l);
    c.r = std::max(a.r, b.r);
    c.a.resize(c.r - c.l + 1);
    for (int i = 0; i < a.a.size(); i++) {
        c.a[i + a.l - c.l] = (c.a[i + a.l - c.l] + a.a[i]) % P;
    }
    for (int i = 0; i < b.a.size(); i++) {
        c.a[i + b.l - c.l] = (c.a[i + b.l - c.l] + b.a[i]) % P;
    }
    return c;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    int n;
    std::cin >> n;

    std::string s;
    std::cin >> s;

    int ans = 0;
    auto solve = [&](auto self, int l, int r) -> std::array<std::array<Poly, 2>, 2> {
        std::array<std::array<Poly, 2>, 2> f;
        if (r - l == 1) {
            for (int i = 0; i < 2; i++) {
                if (s[2 * l] == '?' || s[2 * l] == "YP"[i]) {
                    for (int j = 0; j < 2; j++) {
                        if (i != j) {
                            if (s[2 * l + 1] == '?') {
                                f[i][j].l = -1;
                                f[i][j].r = 1;
                                f[i][j].a = {1, 0, 1};
                            } else if ((s[2 * l + 1] == 'R') ^ i) {
                                f[i][j].l = f[i][j].r = -1;
                                f[i][j].a[0] = 1;
                            } else {
                                f[i][j].l = f[i][j].r = 1;
                                f[i][j].a[0] = 1;
                            }
                        } else {
                            if (s[2 * l + 1] == '?') {
                                f[i][j].a[0] = 2;
                            } else {
                                f[i][j].a[0] = 1;
                            }
                        }
                    }
                }
            }
            return f;
        }
        int m = (l + r) / 2;
        auto L = self(self, l, m);
        auto R = self(self, m, r);
        if (l == 0 && r == n) {
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 2; j++) {
                    for (int x = 0; x < L[i][j].a.size(); x++) {
                        int y = -x - L[i][j].l - R[j][i].l;
                        if (y >= 0 && y < R[j][i].a.size()) {
                            ans = (ans + 1LL * L[i][j].a[x] * R[j][i].a[y]) % P;
                        }
                    }
                }
            }
        } else {
            for (int i = 0; i < 2; i++) {
                for (int j = 0; j < 2; j++) {
                    for (int k = 0; k < 2; k++) {
                        f[i][k] = f[i][k] + L[i][j] * R[j][k];
                    }
                }
            }

        }
        return f;
    };
    auto res = solve(solve, 0, n);
    std::cout << ans << "\n";

    return 0;
}