#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <fstream>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <bitset>
#include <array>
#include <vector>
#include <queue>
#include <set>
#include <cmath> // 変数名にy1が使えなくなるかも…。
#include <map>
#include <unordered_map>
#include <unordered_set>
#include <limits>
#include <functional>
#include <string>

typedef __int128_t int128_t;
std::istream &operator>>(std::istream& input, int128_t& value) { // int128_tの入力。入力が64bitに収まる前提。
    int64_t tmp; input >> tmp; value = tmp;
    return input;
}
std::ostream &operator<<(std::ostream& output, const int128_t value) { // int128_tの出力。出力が64bitに収まる前提。
    output << (int64_t)value;
    return output;
}

int128_t imax(const int128_t a, const int128_t b) { return std::max(a, b); } // std::max, std::min は型が違うとエラーになるため、ラッパーを作る。
int128_t imin(const int128_t a, const int128_t b) { return std::min(a, b); }

#define rep(i, begin, end) for(int64_t i = ((int64_t)begin); i <= ((int64_t)end); i++) // (int64_t)end としておくと、end = v.size() - 2 みたいな入力で、v.size()が1でも正常(end = -1になる）に挙動する。
#define rev(i, begin, end) for(int64_t i = ((int64_t)begin); ((int64_t)end) <= i; i--)

#define input1(begin, end, v1) v1.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i]; }
#define input2(begin, end, v1, v2) v1.resize((end)+1); v2.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i]; } 
#define input3(begin, end, v1, v2, v3) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i]; }
#define input4(begin, end, v1, v2, v3, v4) v1.resize((end)+1); v2.resize((end)+1); v3.resize((end)+1); v4.resize((end)+1); for (int i = (begin); i <= (end); i++) { std::cin >> v1[i] >> v2[i] >> v3[i] >> v4[i]; } 
// input_arrayはbegin = 0のときのみ動作確認。Aの要素の型をテンプレートにして関数にしたほうが丁寧かもしれない。
#define input_array(begin, N, M, A) A.resize((begin)+(N)); for (int i = 0; i < (begin)+(N); i++) { A[i].resize((begin)+(M)); } for (int i = begin; i < (begin)+(N); i++) { for (int j = begin; j < (begin)+(M); j++) { std::cin >> A[i][j]; }}


std::vector<int> irange(const int begin, const int end) {
    std::vector<int> ret; for (int i = begin; i <= end; i++) { ret.push_back(i); }
    return ret;
}

template <typename T>
void printvec(const std::vector<T>& vec) {
    for (int i = 0; i < vec.size(); i++) { std::cout << vec[i] << " "; } std::cout << std::endl;
}

int128_t cal_mod(const int128_t n, const int128_t mod) {
    // n % modを計算する。ただしmod <= 0 ならば何もしない。nが負の場合、正にして補正する。
    if (mod <= 0) {
        return n;
    } else if (0 <= n) {
        return n % mod;
    } else {
        int128_t tmp = (-n) / mod + 1;
        return (n + tmp * mod) % mod;
    }
}

int128_t pow_mod(int128_t x, int128_t n, const int128_t mod) {
    // 累乗の計算。mod <= 0ならば余りの計算は行わない。
    int128_t ret = 1;
    while (n > 0) {
        if (n & 1) { ret = cal_mod(ret * x, mod); }
        x = cal_mod(x * x, mod);
        n = (n >> 1);
    }
    return ret;
}

class Combi_Num {
    // 「組み合わせ数 % 素数」を、前処理を行ったうえでO(1)で求める。modは32bitに収まることが前提。
    public:
    int128_t mod;
    std::vector<int128_t> factorial, factorial_inv, inv;
    Combi_Num() {}
    Combi_Num(const int n, const int128_t mod_in) {
        mod = mod_in;
        factorial.resize(n+1, 0);
        factorial_inv.resize(n+1, 0);
        inv.resize(n+1, 0);
        factorial[0] = 1;
        factorial_inv[0] = 1;
        inv[0] = 1;
        for (int i = 1; i <= n; i++) {
            factorial[i] = (factorial[i-1] * i) % mod;
            inv[i] = pow_mod(i, mod - 2, mod);
            factorial_inv[i] = (factorial_inv[i-1] * inv[i]) % mod;
        }
    }

    int128_t combi(const int n, const int r) const {
        return (factorial[n] * ((factorial_inv[r] * factorial_inv[n-r]) % mod)) % mod;
    }

    int128_t perm(const int n, const int r) const {
        return (factorial[n] * factorial_inv[n-r]) % mod;
    }

    // n個の要素をr個のグループに分ける場合の数。ただし各グループに最低でもm個の要素を入れる。
    // mとしては主に0か1を想定している。
    // 0個の要素を0個のグループに分ける場合の数は1とし、正の個数の要素を0個のグループに分ける場合の数は0とする。
    int128_t separate(const int n, const int r, const int m) const {
        if (n < r * m) { return 0; }
        if (0 < m) { return separate(n - r*m, r, 0); }
        if (n == 0) { return 1; }
        if (r == 0) { return 0; }
        return combi(n + r - 1, r - 1);
    }
};

int N;
//int128_t ;
//std::vector<int> ;
//std::vector<int128_t> ;
std::string S;
//std::vector<std::string> ;
//double ;
//std::vector<double> ;

const int MAX_N = 1e5 + 10;
const int MOD = 998244353;
//const int128_t INF = std::numeric_limits<int64_t>::max();
//using pair = std::pair<int128_t, int>;

Combi_Num cn(MAX_N, MOD);

int main(int argc, char **argv) {
    std::cin >> N;

    input1(1, N*3, S);

    int128_t R = 0;
    int128_t G = 0;
    int128_t B = 0;
    int128_t RG = 0;
    int128_t GB = 0;
    int128_t BR = 0;

    int128_t ret = 1;
    rep (i, 1, N*3) {
        if (S[i] == 'R') {
            if (GB) {
                ret *= GB;
                GB--;
            } else if (B) {
                ret *= B;
                B--;
                BR++;
            } else if (G) {
                ret *= G;
                G--;
                RG++;
            } else {
                R++;
            }
            ret %= MOD;
        } else if (S[i] == 'G') {
            if (BR) {
                ret *= BR;
                BR--;
            } else if (R) {
                ret *= R;
                R--;
                RG++;
            } else if (B) {
                ret *= B;
                B--;
                GB++;
            } else {
                G++;
            }
            ret %= MOD;
        } else if (S[i] == 'B') {
            if (RG) {
                ret *= RG;
                RG--;
            } else if (G) {
                ret *= G;
                G--;
                GB++;
            } else if (R) {
                ret *= R;
                R--;
                BR++;
            } else {
                B++;
            }
            ret %= MOD;
        }
    }

    ret *= cn.factorial[N];
    ret %= MOD;

    std::cout << ret << std::endl;

    return 0;
}

Measured memory_bytes: 5248