#include <bits/stdc++.h>

using std::cin, std::cout;
using std::vector, std::array, std::string;
using std::views::iota, std::views::reverse, std::views::take;

template <class T> using Vec = vector<T>;
template <class T> using Opt = std::optional<T>;

using i64 = int64_t;
using u32 = uint32_t;
using u64 = uint64_t;

std::mt19937_64 mt(std::chrono::steady_clock::now().time_since_epoch().count());

template <class T> T pow(T a, i64 b) {
    assert(b >= 0);
    T r = 1;
    while (b) {
        if (b & 1) r *= a;
        a *= a;
        b >>= 1;
    }
    return r;
}

template <u32 mod> struct ModInt {
    using mint = ModInt;

    static constexpr u32 m = mod;  /// start-hash
    u32 v;
    constexpr ModInt() : v(0) {}
    template <class T> constexpr ModInt(T a) { s(u32(a % m + m)); }
    constexpr mint& s(u32 a) {
        v = a < m ? a : a - m;
        return *this;
    }
    friend mint inv(const mint& n) { return pow(n, m - 2); }  /// end-hash

    mint operator-() const {  /// start-hash
        mint res;
        res.v = v ? m - v : 0;
        return res;
    }  /// end-hash

    friend bool operator==(const mint& a, const mint& b) {
        return a.v == b.v;
    }  /// start-hash
    friend bool operator!=(const mint& a, const mint& b) {
        return !(a == b);
    }  /// end-hash

    mint& operator+=(const mint& o) { return s(v + o.v); }  /// start-hash
    mint& operator-=(const mint& o) { return s(v + m - o.v); }
    mint& operator*=(const mint& o) {
        v = u32(u64(v) * o.v % m);
        return *this;
    }
    mint& operator/=(const mint& o) { return *this *= inv(o); }  /// end-hash

    friend mint operator+(const mint& a, const mint& b) {
        return mint(a) += b;
    }  /// start-hash
    friend mint operator-(const mint& a, const mint& b) { return mint(a) -= b; }
    friend mint operator*(const mint& a, const mint& b) { return mint(a) *= b; }
    friend mint operator/(const mint& a, const mint& b) {
        return mint(a) /= b;
    }  /// end-hash

    static constexpr u32 get_mod() { return m; }
    static constexpr mint get_root() {
        if (m == 998244353) return 3;
        if (m == 1053818881) return 2789;
        assert(false);
    }
};

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

    using Z = ModInt<998244353>;
    constexpr int MAXN = 5234;
    auto fact = Vec<Z>(MAXN);
    fact[0] = 1;
    for (int i : iota(1, MAXN)) fact[i] = fact[i - 1] * i;

    int T;
    cin >> T;
    while (T--) {
        string S;
        cin >> S;
        std::reverse(begin(S), end(S));

        auto dp = Vec<Z>{1};
        for (char c : S) {
            auto ndp = Vec<Z>(size(dp));
            if (c == '1') {
                ndp.emplace_back();
                for (ssize_t j = 0; j < ssize(dp); j++) {
                    // Assign P[i] := i
                    ndp[j] -= dp[j];
                    // Otherwisse
                    ndp[j + 1] += dp[j];
                }
            } else if (c == '0') {
                for (ssize_t j = 0; j < ssize(dp); j++) {
                    ndp[j] += dp[j] * Z(j);
                }
            } else {
                assert(false);
            }

            dp = std::move(ndp);
        }

        Z tot = 0;
        for (ssize_t j = 0; j < ssize(dp); j++) {
            tot += dp[j] * fact[j];
        }
        cout << tot.v << '\n';
    }

    return 0;
}