// https://github.com/yuki-4869/Algorithm/blob/main/Templates/multiple_test_cases.cpp
#include <bits/stdc++.h>
#include <atcoder/all>
using namespace std; using namespace atcoder;
using ll=long long; using LL=__int128; using mint=modint998244353;
using ld = long double;
using pll=pair<ll,ll>; using tu=tuple<ll,ll,ll>; using tu4 = tuple<ll,ll,ll,ll>;using vl=vector<ll>; using vb=vector<bool>; using vvb=vector<vb>; using vvl=vector<vl>; using vs=vector<string>; using vld=vector<long double>; using vc=vector<char>; using vmi=vector<mint>; using vp = vector<pll>; using vt = vector<tu>;using graph = vvl; using Graph = vector<vp>;
template<class T=ll> auto vec2(ll n,ll m,T x=T()){return vector(n,vector<T>(m,x));} template<class T=ll> auto vec3(ll n,ll m,ll l,T x=T()){return vector(n,vector(m,vector<T>(l,x)));}
template<class T=ll> auto vec4(ll a,ll b,ll c,ll d,T x=T()){return vector(a,vector(b,vector(c,vector<T>(d,x))));}
template<class T> using rpq=priority_queue<T,vector<T>,greater<T>>;
using inverse_priority_queue=rpq<ll>;
const ll Inf=2147483647LL, Inf9=1000000000LL, inf=9223372036854775807LL, inf18=1000000000000000000LL, mod=998244353LL;
#define all(v) (v).begin(),(v).end()
#define rall(v) (v).rbegin(),(v).rend()
#define Re(n) for(ll i = 0; i<(ll)(n);i++)
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define rrep(i,n) for(ll i=(ll)(n)-1;i>=0;i--)
#define rep1(i,n) for(ll i=1;i<=(ll)(n);i++)
#define rep3(i,s,t) for(ll i=(ll)(s);i<(ll)(t);i++)
#define pb push_back
#define p(s) cout<<(s)<<'\n'
#define p2(s,t) cout<<(s)<<" "<<(t)<<'\n'
#define p3(s,t,u) cout<<(s)<<" "<<(t)<<" "<<(u)<<'\n'
#define p4(s,t,u,v) cout<<(s)<<" "<<(t)<<" "<<(u)<<" "<<(v)<<'\n'
#define pe(s) cout<<(s)<<' '
#define pval(s) cout<<(s).val()<<'\n'
#define Sort(A) sort(all(A))
#define RSort(A) sort(rall(A))
#define p_yes() p("Yes")
#define p_no() p("No")

template<class T> inline ll sz(const T& x){return (ll)x.size();}
ostream& operator<<(ostream& os,const mint& x){return os<<x.val();}
istream& operator>>(istream& is,mint& x){ll v; is>>v; x=mint(v); return is;}
template<class T> inline bool chmin(T& a,const T& b){if(a>b){a=b; return true;} return false;}
template<class T> inline bool chmax(T& a,const T& b){if(a<b){a=b; return true;} return false;}
template<class T,class U> ll LB(const vector<T>& v,const U& a){return lower_bound(all(v),a)-v.begin();}
template<class T,class U> ll UB(const vector<T>& v,const U& a){return upper_bound(all(v),a)-v.begin();}
template<class T> T vec_min(const vector<T>& v){do { if (!(!v.empty())) std::abort(); } while (false); return *min_element(all(v));}
template<class T> T vec_max(const vector<T>& v){do { if (!(!v.empty())) std::abort(); } while (false); return *max_element(all(v));}
template<class T> T vec_sum(const vector<T>& v){T res=T(0); for(const auto& x:v) res+=x; return res;}

template<class T=ll> vector<T> cin_vl(ll n){vector<T> ret(n); rep(i,n) cin>>ret[i]; return ret;}
template<class T=ll> vector<vector<T>> cin_vvl(ll h,ll w){vector<vector<T>> ret(h,vector<T>(w)); rep(i,h) rep(j,w) cin>>ret[i][j]; return ret;}
template<class T=ll> pair<vector<T>,vector<T>> cin_xy(ll n){vector<T> x(n),y(n); rep(i,n) cin>>x[i]>>y[i]; return {x,y};}
template<class T=ll> tuple<vector<T>,vector<T>,vector<T>> cin_xyz(ll n){vector<T> x(n),y(n),z(n); rep(i,n) cin>>x[i]>>y[i]>>z[i]; return {x,y,z};}
template<class T=ll> vector<vector<T>> Cin_vl(ll n,ll k){vector<vector<T>> ret(k,vector<T>(n)); rep(i,n) rep(j,k) cin>>ret[j][i]; return ret;}
template<class T=ll> vector<pair<T,T>> cin_pairs(ll n){vector<pair<T,T>> ret(n); rep(i,n) cin>>ret[i].first>>ret[i].second; return ret;}
template<class T=ll> vector<tuple<T,T,T>> cin_tuples(ll n){vector<tuple<T,T,T>> ret(n); rep(i,n){T a,b,c; cin>>a>>b>>c; ret[i]={a,b,c};} return ret;}

template<class T> void cout_vl(const vector<T>& a,char sep=' ',char end='\n'){rep(i,sz(a)){if(i) cout<<sep; cout<<a[i];} cout<<end;}
template<class T> void Cout_vl(const vector<T>& a,const vector<T>& b){rep(i,sz(a)) cout<<a[i]<<" "<<b[i]<<'\n';}
template<class T> void cout_vvl(const vector<vector<T>>& a){for(const auto& e:a) cout_vl(e);}
template<class T=ll> void Swap(vector<vector<T>>& v,ll& h,ll& w){vector<vector<T>> ret(w,vector<T>(h));rep(i,h) rep(j,w) ret[j][i]=v[i][j];v.swap(ret);swap(h,w);}

ll ceil_div(ll a,ll b){do { if (!(b!=0)) std::abort(); } while (false); if(b<0) a=-a,b=-b; if(a>=0) return (a+b-1)/b; return -((-a)/b);}
ll floor_div(ll a,ll b){do { if (!(b!=0)) std::abort(); } while (false); if(b<0) a=-a,b=-b; if(a>=0) return a/b; return -((-a+b-1)/b);}
ll isqrt(ll n){ll x=sqrtl(n); while((LL)(x+1)*(x+1)<=n) x++; while((LL)x*x>n) x--; return x;}
template<class T> vector<T> sort_unique_vec(vector<T> v){sort(all(v)); v.erase(unique(all(v)),v.end()); return v;}
template<class T> vector<ll> compress(const vector<T>& v){auto xs=sort_unique_vec(v); vector<ll> ret; for(auto& x:v) ret.pb(LB(xs,x)); return ret;}
template<class T> vector<T> prefix_sum(const vector<T>& v){vector<T> s(sz(v)+1,0); rep(i,sz(v)) s[i+1]=s[i]+v[i]; return s;}
template<class T> vector<vector<T>> prefix_sum2(const vector<vector<T>>& a){int h=sz(a),w=sz(a[0]); vector<vector<T>> s(h+1,vector<T>(w+1,0)); rep(i,h)rep(j,w)s[i+1][j+1]=s[i+1][j]+s[i][j+1]-s[i][j]+a[i][j]; return s;}
template<class T> T range_sum(const vector<T>& s,ll l,ll r){return s[r]-s[l];}
template<class T> vector<pair<T,ll>> run_length(const vector<T>& v){vector<pair<T,ll>> ret; for(auto& x:v){if(ret.empty()||ret.back().first!=x) ret.pb({x,1}); else ret.back().second++;} return ret;}
vector<pair<char,ll>> run_length(const string& s){vector<pair<char,ll>> ret; for(char c:s){if(ret.empty()||ret.back().first!=c) ret.pb({c,1}); else ret.back().second++;} return ret;}
template<class T> ll argmin(const vector<T>& v){do { if (!(!v.empty())) std::abort(); } while (false); return min_element(all(v))-v.begin();}
template<class T> ll argmax(const vector<T>& v){do { if (!(!v.empty())) std::abort(); } while (false); return max_element(all(v))-v.begin();}
template<class T> bool in_vec(const vector<T>& v,const T& x){return binary_search(all(v),x);}

bool even(ll x){return x%2==0;}
bool odd(ll x){return x%2!=0;}
ll grid_id(ll x,ll y,ll w){return x*w+y;}
pll grid_xy(ll id,ll w){return {id/w,id%w};}

ll gcd(ll a,ll b){if(b==0) return abs(a); return gcd(b,a%b);}
ll lcm(ll a,ll b){return a/gcd(a,b)*b;}
ll Exp(ll x,ll y){ll cnt=-1; while(x>0) x/=y,cnt++; return cnt;}
ll powmod(ll x,ll k,ll m){if(k==0) return 1%m; ll r=powmod(x,k/2,m); r=(LL)r*r%m; if(k&1) r=(LL)r*x%m; return r;}
template<class T> T square(T x){return x*x;}
template<class T> void Uni_erase(vector<T>& v){sort(all(v)); v.erase(unique(all(v)),v.end());}
inline bool OutIn(ll x,ll n){return 0<=x&&x<n;}
inline bool OutIn(ll x,ll y,ll h,ll w){return 0<=x&&x<h&&0<=y&&y<w;}
inline bool OutIn(ll x,ll y,ll z,ll a,ll b,ll c){return 0<=x&&x<a&&0<=y&&y<b&&0<=z&&z<c;}
mt19937_64 rng(chrono::steady_clock::now().time_since_epoch().count());
ll Random(ll l,ll r){uniform_int_distribution<ll> dist(l,r-1); return dist(rng);}
void YesNo(bool x){x?p_yes():p_no();}
vl vl_n(ll n){vl ret(n); rep(i,n) ret[i]=i; return ret;}
vl vl_N(ll n){vl ret(n); rep(i,n) ret[i]=i+1; return ret;}

vl dx={0,1,0,-1}, dy={1,0,-1,0};
vl dx8={1,1,0,-1,-1,-1,0,1}, dy8={0,1,1,1,0,-1,-1,-1};

vector<mint> fac,finv,pow2;
void factorial(ll N=1000000LL){ll M=N+100; fac.assign(M+1,1); finv.assign(M+1,1); pow2.assign(M+1,1); rep1(i,M) fac[i]=fac[i-1]*i; finv[M]=fac[M].inv(); for(ll i=M;i>=1;i--) finv[i-1]=finv[i]*i; rep1(i,M) pow2[i]=pow2[i-1]*2;}
void ensure_factorial(ll N){if((ll)fac.size()>N) return; factorial(N);}
mint nCr(ll N,ll r){if(N<0||r<0||N<r) return 0; ensure_factorial(N); return fac[N]*finv[r]*finv[N-r];}
mint nPr(ll N,ll r){if(N<0||r<0||N<r) return 0; ensure_factorial(N); return fac[N]*finv[N-r];}

inline vector<long long> prime_list(long long n){
    vector<bool> is_prime(n+1,true);
    vector<long long> ret;
    if(n>=0) is_prime[0]=false;
    if(n>=1) is_prime[1]=false;
    for(long long p=2;p<=n;p++){
        if(!is_prime[p]) continue;
        ret.push_back(p);
        if(p<=n/p) for(long long x=p*p;x<=n;x+=p) is_prime[x]=false;
    }
    return ret;
}

template<class T> void divisor_zeta(vector<T>& f){
    do { if (!(!f.empty())) std::abort(); } while (false);
    long long n=(long long)f.size()-1;
    for(long long p:prime_list(n)){
        for(long long x=1;x<=n/p;x++) f[x*p]+=f[x];
    }
}

template<class T> void divisor_mobius(vector<T>& f){
    do { if (!(!f.empty())) std::abort(); } while (false);
    long long n=(long long)f.size()-1;
    for(long long p:prime_list(n)){
        for(long long x=n/p;x>=1;x--) f[x*p]-=f[x];
    }
}

template<class T> void multiple_zeta(vector<T>& f){
    do { if (!(!f.empty())) std::abort(); } while (false);
    long long n=(long long)f.size()-1;
    for(long long p:prime_list(n)){
        for(long long x=n/p;x>=1;x--) f[x]+=f[x*p];
    }
}

template<class T> void multiple_mobius(vector<T>& f){
    do { if (!(!f.empty())) std::abort(); } while (false);
    long long n=(long long)f.size()-1;
    for(long long p:prime_list(n)){
        for(long long x=1;x<=n/p;x++) f[x]-=f[x*p];
    }
}

/*
細かい注意点
vector<T> f(N+1)の添字1..Nを使用。f[0]は変更しない。空vectorは渡さない。
Tは+=と-=を持つ型。long longやmodintに対応。
divisor_zetaはf[x]=Σ_{d|x}a[d]、multiple_zetaはf[x]=Σ_{x|m}a[m]。
mobiusは対応するzetaの逆変換。約数側はLCM、倍数側はGCDの集計に使いやすい。
素数列挙を含めて時間O(N log log N)、追加メモリO(N)。
同名の変換関数を持つnumber_theory_bundleとは引数・返り値が異なる。

使える関数一覧
prime_list(N);        // vector<ll>: N以下の素数 O(N log log N)
divisor_zeta(f);      // void: 約数ゼータ変換、その場で更新 O(N log log N)
divisor_mobius(f);    // void: 約数メビウス変換 O(N log log N)
multiple_zeta(f);     // void: 倍数ゼータ変換 O(N log log N)
multiple_mobius(f);   // void: 倍数メビウス変換 O(N log log N)

基本の関数
vl counts(13,1); counts[0]=0;
divisor_zeta(counts);                         // counts[12]==6（約数個数）
divisor_mobius(counts);                       // 元の列へ戻す
multiple_zeta(counts);                        // 倍数側へ累積
multiple_mobius(counts);                      // 元の列へ戻す
*/
vector<ll> get_divisors(ll n) {
    vector<ll> d;
    for (ll i = 1; i * i <= abs(n); i++) {
        if (n % i == 0) {
            d.push_back(i);
            if (i * i != n) d.push_back(n / i);
            if (n < 0) {
                d.push_back(-i);
                if (i * i != n) d.push_back(-n / i);
            }
        }
    }
    sort(d.begin(), d.end());
    return d;
}

/*
細かい注意点
正のnの正の約数を昇順で返す用途で使用する。n=0は約数列挙の対象外。
ループ内のi*iがlong longに収まる値域で使用する。
負数の約数列挙には使用しない。

使える関数一覧
get_divisors(n); // vector<ll>: 正の約数を昇順で列挙 O(sqrt(n)+D log D)、Dは約数個数

基本の関数
auto divisors = get_divisors(12);             // {1,2,3,4,6,12}
*/
struct LinearSieve{
    ll n;
    vector<ll> prime,spf,phi,mu;

    LinearSieve(ll n):n(n),spf(n+1),phi(n+1),mu(n+1){
        if(n>=1)phi[1]=mu[1]=1;
        for(ll i=2;i<=n;i++){
            if(!spf[i])spf[i]=i,prime.push_back(i),phi[i]=i-1,mu[i]=-1;
            for(ll p:prime){
                if(p>spf[i]||i*p>n)break;
                spf[i*p]=p;
                if(i%p==0)phi[i*p]=phi[i]*p,mu[i*p]=0;
                else phi[i*p]=phi[i]*(p-1),mu[i*p]=-mu[i];
            }
        }
    }

    bool isPrime(ll x){return x>=2&&spf[x]==x;}

    vector<pair<ll,ll>> factorize(ll x){
        vector<pair<ll,ll>> res;
        while(x>1){
            ll p=spf[x],c=0;
            while(x%p==0)x/=p,c++;
            res.push_back({p,c});
        }
        return res;
    }

    vector<ll> divisors(ll x){
        vector<ll> d={1};
        for(auto [p,c]:factorize(x)){
            ll s=d.size(),q=1;
            for(ll k=1;k<=c;k++){
                q*=p;
                for(ll i=0;i<s;i++)d.push_back(d[i]*q);
            }
        }
        return d;
    }
};

/*
細かい注意点
NまでO(N)で前計算。isPrimeは対応範囲内、factorize/divisorsは1<=x<=Nで使用する。
primeは素数一覧、spfは最小素因数、phiはEulerのφ関数、muはMöbius関数。
number_theory_bundleのLinearSieveと同名なので同時に貼らない。

使える関数一覧
LinearSieve ls(N); // 構築 O(N)
ls.isPrime(x);     // bool: 素数判定 O(1)
ls.factorize(x);   // vector<pair<ll,ll>>: 素因数と指数 O(log x)
ls.divisors(x);    // vector<ll>: 約数列挙 O(約数個数)
ls.prime;          // vector<ll>: N以下の素数
ls.spf[x], ls.phi[x], ls.mu[x]; // 最小素因数、φ、μ O(1)

基本の関数
LinearSieve ls(100);
auto prime = ls.isPrime(97);                  // true
auto factors = ls.factorize(12);             // {{2,2},{3,1}}
auto divisors = ls.divisors(12);
*/
LinearSieve ls(1010000);
vmi q(21);
void init(){
    rep(i,21){
        rep(a,i+1)rep(b,i+1)rep(c,i+1)rep(d,i+1){
            if(a+c<=i&&b+d<=i&&a+b<=i&&c+d<=i&&a+b+c+d>=i) q[i]++;
        }
    }
}
void solve();
signed main(){
    ios::sync_with_stdio(false); cin.tie(nullptr);

    
    
    ll t;
    cin >> t;
    init();
    rep(i,t) solve();
}
void solve(){
    ll k;
    cin >> k;
    auto v = ls.factorize(k);

    mint ans = 1;
    for(auto[e,f]:v) ans *= q[f];
    p(ans);
}