#include<bits/stdc++.h>
using ll = long long;
#define int ll
using namespace std;


const int mod = 998244353;

class modInt{ // 有模数
    public:
        modInt(const long long x=0): num(x%mod){}
        explicit operator long long() {
            return num;
        }
        friend std::ostream& operator<< (std::ostream& out, const modInt& item) {
            out << item.num;
            return out;
        }
        friend std::istream& operator>> (std::istream& in, modInt& item) {
            in >> item.num;
            return in;
        }
        friend modInt operator^ (modInt a, long long b) {
            modInt res(1);
            if (b == 0) {
                return res;
            }
            for( ; b; a = a * a, b >>= 1)
                if(b&1)
                    res = res * a;
            return res;
        }
        static modInt inv(const modInt x) {
            return x ^ (mod-2);
        }
        friend modInt operator+ (const modInt& lhs, const modInt& rhs) {
            return (lhs.num + rhs.num) % mod;
        }
        modInt& operator+= (const modInt& ano) {
            num = (num + ano.num) % mod;
            return *this;
        }
        friend modInt operator* (const modInt& lhs, const modInt& rhs) {
            return lhs.num * rhs.num % mod;
        }
        modInt& operator*= (const modInt& ano) {
            num = num * ano.num % mod;
            return *this;
        }
        friend modInt operator- (const modInt& lhs, const modInt& rhs) {
            long long tmp = lhs.num-rhs.num;
            return tmp<0 ? tmp+mod : tmp; 
        }
        modInt& operator-= (const modInt& ano) {
            *this = *this - ano;
            return *this;
        }
        friend modInt operator/ (const modInt& lhs, const modInt& rhs) {
            return (lhs * inv(rhs)).num % mod;
        }
        modInt& operator/= (const modInt& ano) {
            *this = *this / ano;
            return *this;
        }
        long long toLL() {
            return num;
        }
    private:
        long long num;
};


int dp[101];

void solve() {
    vector<int> a(11, 0);
    for (int i = 1; i <= 9; ++i) {
        cin >> a[i];
    }
    modInt ans = 1;
    priority_queue<int, vector<int>, greater<int>> q;
    for (int i = 2; i <= 9; ++i) {
        for (int j = 1; j <= a[i]; ++j) {
            q.push(i);
        }
        if (a[i] > 0) {
            ans *= (modInt(i) ^ (a[i]));
        }
        // cout << i << " " << a[i] << " " << ans << "\n";
    }
    ans *= modInt(dp[a[1]]);
    if (q.size() == 0) {
        cout << ans << "\n";
        return;
    }
    //cout << ans << '\n';
    for (int i = a[1]; i > 0; --i) {
        int x = q.top();
        q.pop();
        // x -> x + 1
        // dp[i] -> dp[i-1]
        // * (x+1) / x * (dp[i-1] / dp[i])
        // * (x+1) * dp[i-1] / (x * dp[i])
        // cout << (x * dp[i]) << ' ' << ((x+1) * dp[i-1]) << '\n';
        if (x * dp[i] <= (x+1) * dp[i-1]) {
            ans *= modInt(x+1) * dp[i-1] / (x * dp[i]);
            q.push(x+1);
        } else {
            break;
        }
    }
    cout << ans << "\n";
}

signed main() {
    int T;
    dp[0] = 0;
    for (int i = 1; i <= 100; ++i) {
        dp[i] = dp[i-1] + 1;
        for (int j = 1; j < i; ++j) {
            dp[i] = max(dp[i], dp[j] * dp[i-j]);
        }
    }
    dp[0] = 1;
    cin >> T;
    while (T--) {
        solve();
    }

    return 0;
}

/*
7
5 3 0 0 0 0 0 0 0
4 1 1 1 0 0 0 0 0
1 0 0 0 0 0 0 0 0
1 0 0 0 0 0 0 0 1
1 0 0 0 0 0 0 0 2
99 88 77 66 55 44 33 22 11
100 90 80 70 60 50 40 30 20
*/