#include<iostream>
#include<vector>
#include<map>
#include<set>
#include<unordered_map>
#include<algorithm>
using namespace std;

int const M = 19; // 19

struct entry {
    unsigned long long digit, mpl, count;
};

unsigned long long mpl(unsigned long long n) {
    if (n < 10) {
        return n;
    }
    unsigned long long res = 1;
    while (n > 0) {
        res *= n % 10;
        n /= 10;
    }
    return res;
}

unsigned long long mplf(unsigned long long n) {
    if (n < 10) {
        return n;
    }
    unsigned long long res = 1;
    while (n > 0) {
        res *= n % 10;
        n /= 10;
    }
    return mplf(res);
}

void print(vector<unsigned long long> v) {
    for (unsigned long long i = 0; i < v.size(); i++) {
        cout << v[i] << ' ';
    }    
}

vector<unsigned long long> digits(unsigned long long n) {
    vector<unsigned long long> v;
    while (n > 0) {
        v.push_back(n % 10);
        n /= 10;
    }

    return v;
}

vector<unsigned long long> pos_cache(20);

struct centry {
    unsigned long long digit;
    unsigned long long pos;
    unsigned long long acc;
    bool zeros;
    bool round;
};

bool operator<(const centry &a, const centry &b) {
    if (a.digit < b.digit) return true;
    if (a.digit > b.digit) return false;
    if (a.pos < b.pos) return true;
    if (a.pos > b.pos) return false;
    if (a.acc < b.acc) return true;
    if (a.acc > b.acc) return false;
    if (a.zeros < b.zeros) return true;
    if (a.zeros > b.zeros) return false;
    if (a.round < b.round) return true;
    return false;
}

map<centry, vector<unsigned long long>> compute_cache;

vector<unsigned long long> compute(vector<vector<entry>> &w, vector<vector<vector<entry>>> &aggr, vector<vector<entry>> &aggrh, unsigned long long digit, unsigned long long pos, unsigned long long acc, bool zeros, bool round) {
    if (compute_cache.count({digit, pos, acc, zeros, round}) > 0) {
        return compute_cache[{digit, pos, acc, zeros, round}];
    }
    
    vector<unsigned long long> res(10);

    // numbers with less than 'pos' digits
    if (zeros && ! round) {
        unsigned long long zval = 0;
        if (pos_cache[pos] > 0) {
            zval = pos_cache[pos];
        }
        else {
            if (pos > 0) {
                for (entry &e : aggrh[pos - 1]) { 
                    zval += e.count;
                }                
            }
            pos_cache[pos] = zval;  
        }

        res[0] += zval;
    }

    if (! zeros) {
        if (pos > 0) {
            for (entry &e : aggrh[pos - 1]) { 
                res[mplf(acc * e.mpl)] += e.count;
            }
        }
    }   
    
    // numbers with exatly 'pos' digits but with most significant digit less than 'digit'
    if (digit > 0) {
        for (entry &e : aggr[pos][digit - 1]) {
            res[mplf(acc * e.mpl)] += e.count;
        }
    }

    compute_cache[{digit, pos, acc, zeros, round}] = res;
    return res;
}

vector<unsigned long long> fast_solve(vector<vector<entry>> &w, vector<vector<vector<entry>>> &aggr, vector<vector<entry>> &aggrh, unsigned long long n) {
    vector<unsigned long long> digs = digits(n);

    unsigned long long acc = 1;
    vector<unsigned long long> res(10);
    for (int i = digs.size() - 1; i >= 0; i--) {
        vector<unsigned long long> ret = compute(w, aggr, aggrh, digs[i], i, acc, i != digs.size() - 1, digs[i] == 0);
        for (unsigned long long d = 0; d < 10; d++) {
            res[d] += ret[d];
        }        

        acc *= digs[i];
    }

    // correction
    res[0]--;
    res[mplf(n)]++;

    return res;
}

vector<unsigned long long> brut_solve(unsigned long long n) {
    vector<unsigned long long> res(10);
    for (int i = 1; i <= n; i++) {
        res[mplf(i)]++;
    }
    return res;
}

int main() {
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    vector<vector<entry>> w(M);
    vector<vector<vector<entry>>> aggr(M, vector<vector<entry>>(10));

    for (unsigned long long i = 0; i < 10; i++) {
        w[0].push_back({i, i, 1l});
        aggr[0][i].push_back({i, i, 1l});
        for (unsigned long long j = 0; j < i; j++) {
            aggr[0][i].push_back({j, j, 1l});
        }
    }

    for (unsigned long long i = 1; i < M; i++) {
        vector<unordered_map<long long, long long>> m(10);
        for (entry &e : w[i - 1]) {
            for (unsigned long long d = 1; d < 10; d++) {
                long long key = d * e.mpl;
                if (key % 10 == 0) {
                    key = 0;
                }
                m[d][key] += e.count;
            }
        }

        for (long long j = i - 2; j >= 0; j--) {
            for (entry &e : w[j]) {
                for (int d = 1; d < 10; d++) {
                    m[d][0] += e.count;
                }
            }
        }        

        // compute size and reserve
        unsigned long long size = 0;
        for (unsigned long long i = 0; i < 10; i++) {
            size += m[i].size();
        }        
        w[i].reserve(size);

        for (unsigned long long d = 0; d < 10; d++) {
            aggr[i][d].reserve(5 * size);
            for (const pair<unsigned long long, unsigned long long> &e : m[d]){
                w[i].push_back({d, e.first, e.second});
            }

            if (d > 0) {
                for (const pair<unsigned long long, unsigned long long> &e : m[d - 1]) {
                    m[d][e.first] += e.second;
                }                
            }
            
            for (const pair<unsigned long long, unsigned long long> &e : m[d]){
                aggr[i][d].push_back({d, e.first, e.second});
            }
        }
    }
    
    vector<vector<entry>> aggrh(M);
    for (int i = 0; i < M; i++) {
        unordered_map<unsigned long long, unsigned long long> m;
        for (const entry &e : aggr[i][9]) {
            m[e.mpl] += e.count;
        }
        if (i > 0) {
            for (int j = 0; j < i; j++) {
                for (const entry &e : aggr[j][9]) {
                    m[e.mpl] += e.count;
                }    
            }            
        }
        for (const pair<unsigned long long, unsigned long long> &p : m) {
            aggrh[i].push_back({0, p.first, p.second});
        }        
    }
    
    // int R = 5;
    // long long sum1 = 0;
    // for (int i = 0; i < R; i++) {
    //     for (const entry &e : aggr[i][9]) {
    //         sum1 += e.count;
    //     }
    // }
    // cout << sum1 << endl;
    
    // long long sum2 = 0;
    // for (const entry &e : aggrh[R - 1]) {
    //     sum2 += e.count;
    // }
    // cout << sum2 << endl;


    unsigned long long t;
    cin >> t;

    while (t--) {
        unsigned long long l;
        cin >> l;

        vector<unsigned long long> f = fast_solve(w, aggr, aggrh, l);
        print(f);
        cout << endl;
    }
    
    return 0;
}