#include <cstdio>
#include <cstring>
#include <algorithm>
#include <utility>
#include <vector>
#include <array>
#define FILEIO(filename) (freopen(filename ".in", "r", stdin), freopen(filename ".out", "w", stdout))
typedef long long ll;
typedef unsigned long long ull;
using std::pair, std::vector, std::array;
constexpr int N = 50005, mod = 998244353;
inline constexpr int qpow(int x, int y)
{
    int res = 1;
    for (; y; y >>= 1, x = 1ll * x * x % mod)
        if (y & 1)
            res = 1ll * res * x % mod;
    return res;
}
inline constexpr int qmod(int x)
{
    return x >= mod ? x - mod : x;
}
constexpr int G = 3;
inline vector<int> pwinit(int mx)
{
    vector<int> res(mx << 1);
    for (int i = 1; i <= mx; i <<= 1)
    {
        int w = qpow(G, (mod - 1) / (i << 1));
        for (int j = 0, cur = 1; j < i; ++j, cur = 1ll * cur * w % mod)
            res[i + j] = cur;
    }
    return res;
}
const vector<int> pwG = pwinit(1 << 18);
class Poly : public vector<int>
{
    inline Poly dft(int n) const
    {
        Poly res(*this);
        res.resize(n);
        for (int l = n >> 1; l;l >>= 1)
            for (int i = 0; i < n;i += (l << 1))
                for (int j = 0; j < l;++j)
                {
                    int v = res[i + j + l];
                    res[i + j + l] = 1ll * pwG[l + j] * (res[i + j] + mod - v) % mod;
                    res[i + j] = qmod(res[i + j] + v);
                }
        return res;
    }
    inline Poly idft(int n) const
    {
        Poly res(*this);
        res.resize(n);
        for (int l = 1; l < n; l <<= 1)
            for (int i = 0; i < n; i += (l << 1))
                for (int j = 0; j < l; ++j)
                {
                    int v = 1ll * pwG[l + j] * res[i + j + l] % mod;
                    res[i + j + l] = qmod(res[i + j] + mod - v);
                    res[i + j] = qmod(res[i + j] + v);
                }
        std::reverse(res.begin() + 1, res.end());
        res = res * qpow(n, mod - 2);
        return res;
    }
    inline static Poly cycconv(const Poly &a, const Poly &b, int n)
    {
        if (n <= 128 || std::min(a.size(), b.size()) <= 64)
        {
            Poly res(n);
            for (int i = 0; i < (int)a.size(); ++i)
                for (int j = 0; j < (int)b.size(); ++j)
                    res[(i + j) & (n - 1)] = (res[(i + j) & (n - 1)] + 1ll * a[i] * b[j]) % mod;
            return res;
        }
        Poly &&ta = a.dft(n), &&tb = b.dft(n);
        Poly res(n);
        for (int i = 0; i < n; ++i)
            res[i] = 1ll * ta[i] * tb[i] % mod;
        res = res.idft(n);
        return res;
    }

    public:
    explicit Poly(int n = 0) : vector(n)
    {
        return;
    }
    explicit Poly(std::initializer_list<int> v) : vector(v)
    {
        return;
    }
    explicit Poly(std::vector<int> v) : vector(v)
    {
        return;
    }
    inline Poly rev(void) const
    {
        Poly res(*this);
        std::reverse(res.begin(), res.end());
        return res;
    }
    inline Poly substr(int l, int r) const
    {
        Poly res;
        res.insert(res.end(), this->begin() + l, this->begin() + r);
        return res;
    }
    inline friend Poly operator+(const Poly &a, const Poly &b)
    {
        int n = std::max(a.size(), b.size());
        Poly res(a);
        res.resize(n);
        for (int i = 0; i < (int)b.size(); ++i)
            res[i] = qmod(res[i] + b[i]);
        return res;
    }
    inline friend Poly operator-(const Poly &a, const Poly &b)
    {
        int n = std::max(a.size(), b.size());
        Poly res(a);
        res.resize(n);
        for (int i = 0; i < (int)b.size(); ++i)
            res[i] = qmod(res[i] + mod - b[i]);
        return res;
    }
    inline friend Poly operator*(const Poly &a, int b)
    {
        Poly res(a);
        for (int &x : res)
            x = 1ll * x * b % mod;
        return res;
    }
    inline friend Poly operator*(int a, const Poly &b)
    {
        Poly res(b);
        for (int &x : res)
            x = 1ll * x * a % mod;
        return res;
    }
    inline int operator()(int a)
    {
        int res = 0;
        for (int i = 0, cur = 1; i < (int)size();++i, cur = 1ll * cur * a % mod)
            res = (res + 1ll * cur * at(i)) % mod;
        return res;
    }
    inline friend Poly operator*(const Poly &a, const Poly &b)
    {
        if(a.empty() || b.empty())
            return Poly();
        int n = 1;
        while (n < (int)(a.size() + b.size() - 1))
            n <<= 1;
        Poly res(cycconv(a, b, n));
        res.resize(a.size() + b.size() - 1);
        return res;
    }
    inline void add(int p, int v)
    {
        if(v == 0)
            return;
        if ((int)this->size() <= p)
            resize(p + 1);
        this->at(p) = (this->at(p) + v) % mod;
        return;
    }
};
using Info = array<array<Poly, 2>, 2>;
Info operator+(Info a, const Info &b)
{
    for (int x = 0; x < 2;++x)
        for (int y = 0; y < 2;++y)
            a[x][y] = a[x][y] + b[x][y];
    return a;
}
Info operator*(Info a, int b)
{
    for (int x = 0; x < 2; ++x)
        for (int y = 0; y < 2; ++y)
            a[x][y] = a[x][y] * b;
    return a;
}
Info operator*(const Info &a, const Info &b)
{
    Info res;
    for (int i = 0; i < 2; ++i)
        for (int j = 0; j < 2;++j)
            for (int k = 0; k < 2;++k)
                for (int l = 0; l < 2;++l)
                {
                    if(j != k)
                        res[i][l] = res[i][l] + a[i][j] * b[k][l];
                    else
                    {
                        Poly tmp = a[i][j] * b[k][l].rev();
                        for (int x = 0; x < (int)tmp.size();++x)
                        {
                            int id = x - (int)b[k][l].size() + 1;
                            if(id < 0)
                                res[i ^ 1][l].add(-id, tmp[x]);
                            else
                                res[i][l ^ 1].add(id, tmp[x]);
                        }
                    }
                }
    return res;
}
using Group = array<array<Info, 2>, 2>;
int n, lim[2][N];
char s[N << 1];
Group solve(int l, int r)
{
    Group res;
    if (r - l == 1)
    {
        if(lim[1][l] & 1)
            res[0][0][0][1].add(0, 1);
        if (lim[1][l] & 2)
            res[1][1][0][1].add(0, 1);
        return res;
    }
    int mid = (l + r) >> 1;
    Group vl = solve(l, mid), vr = solve(mid, r);
    for (int x = 0; x < 2;++x)
        for (int y = 0; y < 2;++y)
            for (int z = 0; z < 2;++z)
                for (int w = 0; w < 2;++w)
                {
                    if(y == z)
                        res[x][w] = res[x][w] + vl[x][y] * vr[z][w] * ((lim[0][mid] & 1) + (lim[0][mid] >> 1));
                    else
                    {
                        Info tmp;
                        if(lim[0][mid] & 1)
                            tmp[0][0].add(1, 1);
                        if(lim[0][mid] & 2)
                            tmp[1][1].add(1, 1);
                        res[x][w] = res[x][w] + vl[x][y] * tmp * vr[z][w];
                    }
                }
    return res;
}
int main(void)
{
    scanf("%d", &n);
    scanf("%s", s);
    std::rotate(s, s + 1, s + 2 * n);
    for (int i = 0; i < n; ++i)
    {
        if(s[2 * i] == '?')
            lim[0][i] = 3;
        else if(s[2 * i] == 'R')
            lim[0][i] = 1;
        else
            lim[0][i] = 2;
        if(s[2 * i + 1] == '?')
            lim[1][i] = 3;
        else if(s[2 * i + 1] == 'Y')
            lim[1][i] = 1;
        else
            lim[1][i] = 2;
    }
    Group res = solve(0, n);
    Info tmp;
    if (lim[0][0] & 1)
        tmp[0][0].add(1, 1);
    if (lim[0][0] & 2)
        tmp[1][1].add(1, 1);
    int ans = 0;
    for (int i = 0; i < 2;++i)
        for (int j = 0; j < 2;++j)
        {
            if(i == j)
                res[i][j] = res[i][j] * ((lim[0][0] & 1) + (lim[0][0] >> 1));
            else
                res[i][j] = res[i][j] * tmp;
            for (int x = 0; x < 2;++x)
                if(res[i][j][x][x ^ 1].size())
                    ans = (ans + res[i][j][x][x ^ 1][0]) % mod;
        }
    printf("%d\n", ans);
    return 0;
}