#include <bits/stdc++.h>
// #include <ext/pb_ds/assoc_container.hpp>
// #include <ext/pb_ds/tree_policy.hpp>
// #include <ext/rope>

using namespace std;
// using namespace __gnu_pbds;

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned int uint;
typedef long double ld;

template <class T>

using VV = vector<vector<T>>;

using VI = vector<int>;
using VVI = vector<vector<int>>;

using VL = vector<long long>;
using VVL = vector<vector<long long>>;

using VC = vector<char>;
using VVC = vector<vector<char>>;

using VB = vector<bool>;
using VVB = vector<vector<bool>>;

using VD = vector<double>;
using VVD = vector<vector<double>>;

using PII = pair<int, int>;
using PLL = pair<long long, long long>;
using PIL = pair<int, long long>;
using PLI = pair<long long, int>;

using VPII = vector<pair<int, int>>;
using VPLL = vector<pair<long long, long long>>;

#define LINE '\n'
#define SPACE ' '
#define PB push_back
#define FOR(i, a, b) for (int i = (a); i < (int(b)); i++)
#define FORE(i, a, b) for (int i = (a); i <= (int)((b)); i++)
#define ALL(x) x.begin(), x.end()
#define RALL(x) x.rbegin(), x.rend()
#define sq(a) ((a) * (a))
#define sz(x) ((int)x.size())

#define fastio()                      \
    ios_base::sync_with_stdio(false); \
    cin.tie(nullptr);                 \
    cout.tie(nullptr)
#define debug(x) cerr << #x << " = " << x << endl;

const ll MOD = 1e9 + 7;

template <class T>
inline void maxi(T &a, T b)
{
    a = max(a, b);
}

template <class T>
inline void mini(T &a, T b)
{
    a = min(a, b);
}

template <class T>
inline void addi(T &a, T b)
{
    a = (a + b) % MOD;
}

template <class T>
inline void subi(T &a, T b)
{
    a = (a - b + MOD) % MOD;
}

template <class T>
inline T add(T a, T b)
{
    return (a + b) % MOD;
}

template <class T>
inline T sub(T a, T b)
{
    return (a - b + MOD) % MOD;
}

template <class T>
inline T mul(T a, T b)
{
    return ((a % MOD) * (b % MOD)) % MOD;
}

const ll MAX_N = 1e18;
const int MAX_LEN = 18;

map<ll, ll> dpraw[MAX_LEN + 1];
VPLL dp[MAX_LEN  + 1];
VPLL states;
VI num;
int len;

VVL ctValids(MAX_LEN + 1, VL(10, 0));

int getDigit(ll num) {
    if(num == 0) return 0;
    while(num >= 10) {
        ll prod = 1;
        ll temp = num;
        while(temp > 0) {
            prod *= (temp % 10);
            temp /= 10;
        }
        num = prod;
    }

    return num;
}

VI getNum(ll num)
{
    VI res;
    if (num == 0)
        res = {0};
    while (num > 0)
    {
        res.PB(num % 10);
        num /= 10;
    }
    reverse(ALL(res));
    return res;
}

// liczy dla dlugosci 1...Len ile mozna uzyskac roznych prod.
// pozwala na zera wiodące
void comp_dpraw()
{
    dpraw[0][1] = 1;
    FOR(i, 0, 10) {
        dpraw[1][i] = 1;
    }
    
    FOR(i, 2, MAX_LEN+1)
    {
        // digit at the curr pos i
        FOR(d, 0, 10)
        {
            // for each digit multiply by all stany z dp[i-1]
            for (auto [key, val] : dpraw[i - 1])
            {
                ll newkey = key * (ll)d;
                if(newkey % 10 == 0) newkey = 0;
                dpraw[i][newkey] += val;
            }
        }
    }
}

// mnozy sufiks przez prefiks prod
void update_states(ll prod, const VPLL &st)
{
    ll zeroct = 0;
    for (auto &[pr, ct] : st)
    {
        ll newprod = pr * prod;
        if(newprod % 10 == 0) zeroct += ct;
        else states.PB({newprod, ct});
    }

    states.PB({0, zeroct});
}


VL statesToCter()
{
    VL res(10, 0);
    map<ll, ll> mp;
    for (auto [prod, ct] : states) {
        mp[prod] += ct;
    }
    
    int c = 0;
    for (auto [prod, ct] : mp)
    {
        assert(prod >= 0);
        assert(prod <= 1e18);
        int d = getDigit(prod);
        res[d] += ct;
        c += d == 0;
    }

   //debug(sz(states));

    return res;
}


void calcForLen(int L)
{
    if (L == 1)
    {
        FOR(i, 1, 10)
            ctValids[L][i] = 1;
        return;
    }

    // digit to make it valid
    states.clear();
    FOR(d, 1, 10)
    {
        update_states(d, dp[L - 1]);
    }

    ctValids[L] = statesToCter();
}



void calc_dp()
{
    // iterowanie po rozpatrywanej cyfrze
    ll prod = 1;
    FOR(i, 0, len)
    {
        int sufit = num[i];
        int beg = (i == 0 ? 1 : 0);
        FOR(d, beg, sufit)
        {
            ll newprod = prod * d;
            assert(newprod >= 0);
            int left = len - 1 - i; // zostalo na suffiksie


            if (left == 0)
                states.PB({newprod, 1});
            else
                update_states(newprod, dp[left]);
        }
        prod *= sufit;
    }

    assert(prod >= 0);
    states.PB({prod, 1});
}

void solve()
{
    int t;
    cin >> t;

    comp_dpraw();
    FOR(i, 0, MAX_LEN + 1)
    {
        for (auto &[key, value] : dpraw[i])
        {
            dp[i].PB({key, value});
        }
    }

    FOR(L, 1, MAX_LEN + 1) {
        calcForLen(L);
    }

    FOR(L, 1, MAX_LEN + 1) {
        FOR(d, 0, 10) ctValids[L][d] += ctValids[L-1][d];
    }

    
    while (t--)
    {
        ll n;
        cin >> n;

        num = getNum(n);
        len = sz(num);
        states.clear();

        calc_dp();
        VL cter = statesToCter();
        
        FOR(d, 0, 10) cter[d] += ctValids[len-1][d];
        

        if(n == (ll)1e18) cter[0]++;

        FOR(i, 0, 10)
        {
            cout << cter[i] << SPACE;
        }
        cout << LINE;
    }
}
 
int main()
{
    fastio();

    solve();
}