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

#ifdef LOCAL
#include "../debug/debug.h"
#else
#define debug(...)
#define debugArr(...)
#endif

using namespace std;
using namespace __gnu_pbds;

using ll = long long;
using db = long double;
using pi = pair<int,int>;
using pl = pair<ll,ll>;
using vi = vector<int>;
using vl = vector<ll>;
using vb = vector<bool>;
using vpi = vector<pi>;
using vpl = vector<pl>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using vvpi = vector<vpi>;

#define mp make_pair
#define eb emplace_back
#define pb push_back
#define x first
#define y second
#define sz(x) int((x).size())
#define bg(x) begin(x)
#define all(x) (x).begin(),(x).end()
#define rall(x) (x).rbegin(), (x).rend() 
#define rep(i,a,b) for(int i=(a);i<(b);i++)
#define per(i,a,b) for(int i=(b)-1;i>=(a);i--)
#define ft front()
#define bk back()
#define rsz resize
#define ins insert
#define each(a,x) for(auto&a:x)

template<class T> bool ckmin(T& a, T b) { return b<a?a=b,1:0; }
template<class T> bool ckmax(T& a, T b) { return b>a?a=b,1:0; }
template<class T> int lwb(vector<T>& a, const T& b) { return int(lower_bound(all(a),b)-bg(a)); }
template<class T> int upb(vector<T>& a, const T& b) { return int(upper_bound(all(a),b)-bg(a)); }
template<class T> void remdup(vector<T>& v) { sort(all(v)); v.erase(unique(all(v)),end(v)); }

constexpr int pct(int x) { return __builtin_popcount(x); }
constexpr int bitlog(int x) { return x == 0 ? 0 : 31 - __builtin_clz(x); }
constexpr int pct(ll x) { return __builtin_popcountll(x); }
constexpr int bitlog(ll x) { return x == 0 ? 0 : 63 - __builtin_clzll(x); }

constexpr ll cdiv(ll a, ll b) { return a / b + ((a ^ b) > 0 && a % b); }  // divide a by b rounded up
constexpr ll fdiv(ll a, ll b) { return a / b - ((a ^ b) < 0 && a % b); }  // divide a by b rounded down
constexpr int cdiv(int a, int b) { return a / b + ((a ^ b) > 0 && a % b); }  // divide a by b rounded down
constexpr int fdiv(int a, int b) { return a / b - ((a ^ b) < 0 && a % b); }  // divide a by b rounded down

const pi MOVES[] = {{-1, 0}, {0, -1}, {1, 0}, {0, 1}};

#ifdef LOCAL
mt19937_64 rng(0xabadbeef);
#else
mt19937_64 rng(chrono::high_resolution_clock::now().time_since_epoch().count());
#endif

ll randr(ll l, ll r) { return uniform_int_distribution<ll>(l, r)(rng); }

const ll MAX = 1e18;
const int L = 20;
ll binom[L][L];

void init_binom() {
    rep(i,0,L) {
        binom[i][0] = binom[i][i] = 1;
        rep(j,1,i) {
            binom[i][j] = binom[i-1][j-1] + binom[i-1][j];
        }
    }
}

ll f(ll x) {
    ll res = 1;
    while (x) {
        res *= x % 10;
        x /= 10;
    }
    return res;
}

int frec(ll x) {
    while (x >= 10) x = f(x);
    return (int)x;
}

vl after_one_move[10];

unordered_set<ll> memo_interesting;

void interesting_backtrack(ll x, int d) {
    if (x > MAX) return;

    auto [_, inserted] = memo_interesting.insert(x);
    if (!inserted) return;

    after_one_move[frec(x)].eb(x);

    rep(i,d,10) {
        interesting_backtrack(x * i, i);
    }
}

void init_interesting() {
    interesting_backtrack(1, 2);
}

unordered_map<ll, vector<array<int, 10>>> memo_distrib;

void distrib_backtrack(array<int, 10> &cur, ll prod, int d, int length) {
    if (prod > MAX) return;
    if (length >= L) return;

    memo_distrib[prod].eb(cur);
    
    rep(i,d,10) {
        cur[i]++;
        distrib_backtrack(cur, prod * i, i, length + 1);
        cur[i]--;
    }
}

void init_distrib() {
    array<int, 10> cur;
    fill(all(cur), 0);

    distrib_backtrack(cur, 1, 2, 0);
}

unordered_map<ll, ll> memo_equal_length[L];    // length -> prod -> cnt
unordered_map<ll, ll> memo_smaller_length[L];  // length -> prod -> cnt

ll dp_fixed_length(int length, ll prod) {
    auto it = memo_equal_length[length].find(prod);
    if (it != memo_equal_length[length].end()) {
        return it->y;
    }

    vl res(L, 0);

    const auto& distribs = memo_distrib[prod];

    for (const auto &v : distribs) {
        int sum_length = accumulate(all(v), 0);
        
        rep(l,sum_length,L) {
            int left = l;
            ll cur = 1;
            rep(i,2,10) {
                cur *= binom[left][v[i]];
                left -= v[i];
            }

            res[l] += cur;
        }
    }

    rep(i,1,L) {
        memo_equal_length[i][prod] = res[i];
    }

    return res[length];
}

ll dp_length_less_than(int length, ll prod) {
    if (length == 1) return 0;

    auto it = memo_smaller_length[length].find(prod);
    if (it != memo_smaller_length[length].end()) {
        return it->y;
    }

    ll res = dp_fixed_length(length - 1, prod) + dp_length_less_than(length - 1, prod);
    return memo_smaller_length[length][prod] = res;
}

ll dp(vi n_digits, ll prod) {
    if (n_digits.empty()) return prod == 1;

    int d = n_digits.back();
    if (d == 0) return 0;

    ll res = 0;
    rep(i,1,d) {
        if (prod % i == 0) {
            res += dp_fixed_length(sz(n_digits) - 1, prod / i);
        }
    }

    if (prod % d == 0) {
        n_digits.pop_back();
        res += dp(n_digits, prod / d);
    }

    return res;
}

ll calc(ll n, ll prod) {
    vi n_digits;
    ll x = n;
    while (x) {
        n_digits.eb(x % 10);
        x /= 10;
    }

    ll length_equal = dp(n_digits, prod);
    ll length_less = dp_length_less_than(sz(n_digits), prod);
    ll res = length_equal + length_less;

    return res;
}

void solve() {
    ll n;
    cin >> n;
    vl res(10, 0);
    rep(i,1,10) {
        for (auto prod : after_one_move[i]) {
            ll cur = calc(n, prod);
            res[i] += cur;
        }
    }
    res[0] = n;
    rep(i,1,10) res[0] -= res[i];
    rep(i,0,10) cout << res[i] << ' ';
    cout << '\n'; 
}

signed main() {
    cin.tie(0)->sync_with_stdio(0);

    init_interesting();
    init_binom();
    init_distrib();

    int t;
    cin >> t;
    while (t--) {
        solve();
    }

    return 0;
}