#include <iostream>
#include <cmath>
#include <vector>
#include <algorithm>

const int MD = 20;

int64_t F[MD];
int64_t S[MD][MD]; // (n over k)
char C[MD];
char C2[MD];
int C2l;

const int MAX = 14000000;

char N[MAX][MD];
char B[MAX];
int D[MAX];
int Z[MAX];
int nc = 0;
int64_t CCV[MD][10];
std::vector<int> DDN[MD];

void toD2(int64_t v) {
    C2l = 0;
    while (v > 0) {
        C2[C2l] = v%10;
        v/=10;
        ++C2l;
    }
    C2[C2l] = 0;
    std::reverse(C2, C2+C2l);
}

void toD(int64_t x, int z = 0) {
    int& d = D[nc];
    Z[nc] = z;
    char *NN = N[nc];
    while (z > 0) {
        NN[d] = 0;
        ++d;
        --z;
    }
    while (x > 0) {
        NN[d] = x%10;
        x/=10;
        ++d;
    }
    DDN[d].push_back(nc);
    ++nc;
}

// int64_t mul(int64_t x) {
//     int64_t y = 1;
//     for (char c : std::to_string(x)) {
//         y *= c-'0';
//     }
//     return y;
// }

int64_t mul2(int64_t x) {
    int64_t y = 1;
    while (x > 0) {
        y*=x%10;
        x/=10;
    }
    return y;
}

int64_t brute(int64_t x) {
    int64_t y = mul2(x);
    if (y > 9) return brute(y);
    else return y;
}

int64_t count = 0;

void gen(int k, int d, std::string prefix) {
    if (d>9) return;
    if (k == 0) {
        ++count;
        // std::clog << prefix << std::endl;
    } else {
        if (d == -1) gen(k-1, d, prefix);
        else gen(k-1, d, prefix + char('0'+d));
        gen(k, d+1, prefix);
    }
}

struct CC {
    int fc, fd, fz;
    int64_t ff;

    // CC(): fc(0), fd(0), ff(1) {}
    
    CC add(int d) {
        if (d == 0) return {fc, fd, fz+1, ff};
        else return {fc+1, fd+1, fz, ff};
    }

    CC apply() {
        return {fc, 0, fz, ff*F[fd]};
    }

    int64_t total() {
        // if (fz > 0) std::clog << fz << " :: " << F[fc]/ff << " vs " << (F[fc]/ff) / (F[fc-1]/ff/F[fz-1]) << std::endl;
        // if (fz == 0) return F[fc]/ff;
        // else return (F[fc]/ff)/(F[fc-1]/ff/F[fz-1]);
        // return fz*F[fc-1]/ff/F[fd];
        if (fc == 0) return 0;
        // return F[fc]/ff/F[fd]*(F[fc+fz-1]/F[fc-1]/F[fz]);
        return F[fc]/(ff*F[fd])*S[fc+fz-1][fz];
    }
};

int64_t vvv;

struct CC2 {

    static CC2 make(int n) {
        CC2 cc;
        cc.n = n;
        cc.d = D[n];
        cc.C[0] = Z[n];
        for (int i=0;i<10;++i) cc.C[i] = 0;
        for (int i;i<cc.d;++i) {
            ++cc.C[N[n][i]];
        }
        cc.fd = 1;
        for (int i=0;i<10;++i) cc.fd *= F[cc.C[i]];
        return cc;
    }

    CC2 without(int digit) const {
        CC2 cc2 = *this;
        cc2.fd /= cc2.C[digit];
        --cc2.C[digit];
        --cc2.d;
        return cc2;
    }

    int64_t total() const {
        if (d == 0) return 1;
        // int64_t ttl = F[d];
        // for (int i=0;i<10;++i) ttl /= F[C[i]];
        // return ttl;
        return F[d] / fd;
        
    }

    // // C2 <= this
    int64_t count_le(int nv, bool start = false) {
        if (d == 0) return 0;
        int d1 = start ? 1 : 0;
        int64_t total = 0;
        while (d1 < C2[nv]) {
            if (C[d1] > 0) {
                // std::clog << d1 << "(" << N[n][d] << ")" << " : " << without(d1).total() << std::endl;
                total += without(d1).total();
            }
            ++d1;
        }
        // std::clog << "::: ::: " << total << " " << d1 << " " << int(C2[nv]) << std::endl;
        // d1 == C2[nv]
        if (d == 1) return total + C[d1];
        else if (C[d1] > 0) return total + without(d1).count_le(nv+1);
        else return total;
    }

    char C[10];
    int64_t fd;
    int d;
    int n;
};

// int64_t C[10];

void gen(int k, int d, int64_t p, int z, CC cc) {
    if (k == 0) {
        if (p == 0) {
            ++count;
            return;
        } else if (z > 0) {
            B[nc] = 0;
            toD(p, z);
            CCV[cc.fc + z][0] += cc.total();
            // C[0] += cc.total();
        } else {
            int bb = B[nc] = brute(p);
            toD(p);
            CCV[cc.fc + z][bb] += cc.total();
            //C[brute(p)] += cc.total();
        }
        // std::clog << std::string(z, '0') << p << " = " << brute(p) << " x " << cc.total() << std::endl;
    } else {
        if (d == -1) gen(k-1, d, p, z, cc);
        else if (d == 0) gen(k-1, d, p*10+d, z+1, cc.add(d));
        else gen(k-1, d, p*10+d, z, cc.add(d));
        if (d<9) gen(k, d+1, p, z, cc.apply());
    }
}

int64_t count_le(int n) {
    CC2 cc = CC2::make(n);
    return cc.count_le(0, true);
}

int64_t CV[10];


void solve(int64_t v) {
    vvv = v;
    toD2(v);
    for (int i=0;i<10;++i) CV[i] = 0;

    int d = 0;
    while (v > 9) {
        ++d;
        for (int i=0;i<10;++i) CV[i] += CCV[d][i];
        v /= 10;
    }
    for (int n : DDN[d+1]) {
        int64_t cl = count_le(n);
        // std::clog << B[n] << " :: " << std::string(Z[n], '0');
        // for (int i=0;i<D[n];++i) std::clog << int(N[n][i]);
        // std::clog << " <= " << v << " = " << cl << std::endl;
        CV[B[n]] += cl;
    }
}

int64_t T[1001];

int main() {
    std::ios_base::sync_with_stdio(0);

    F[0] = 1;
    for (int i=1;i<MD;++i) F[i] = F[i-1]*i;
    for (int i=0;i<MD;++i) S[i][0] = S[i][i] = 1;
    for (int i=1;i<MD;++i) for (int j=1;j<MD;++j)  S[i][j] = S[i-1][j-1] + S[i-1][j];

    // C[0] = 1;
    CCV[0][0] = 1;

    int t;
    std::cin >> t;
    int digits = 1;
    for (int i=0;i<t;++i) {
        int64_t v;
        std::cin >> T[i];
        toD2(T[i]);
        digits = std::max(digits, C2l);
    }

    gen(std::min(digits, 18), -1, 0, 0, {0,0,0,1});
    gen(0, 19, 1, 18, {1, 1, 18, 1});

    for (int i=0;i<t;++i) {
        solve(T[i]);
        std::cout << CV[0];
        for (int i=1;i<10;++i) std::cout << " " << CV[i];
        // std::cout << "\n";
        std::cout << std::endl;
    }

    // std::cin >> n;
    // gen(n, -1, 0, 0, {0,0,0,1});

    // for (int i=0;i<10;++i) std::cout << " " << C[i];
    // std::cout << std::endl;
    // std::cout.precision(4);
    // for (int i=0;i<10;++i) std::cout << " " << std::fixed << double(C[i])/pow(10,n)*100;
    // std::cout << std::endl;

    // int64_t total = 0;
    // for (int i=0;i<10;++i) total += C[i];
    // std::cout << "Total = " << std::fixed << double(total)/pow(10,n)*100;

    // std::clog << "COUNT OF ZEROS = " << count << std::endl;
    // std::cin >> n;
    
    // for (int i= 0;i<n;++i) {
    //     std::cout << i << " = " << brute(i) << " %= " << mul(i)%10 << std::endl;
    // }

    return 0;
}