#include <iostream>
#include <map>

using namespace std;

map<int, long long> count(long long n, int exp, bool count0, bool cach);

int getDigit(int factor);

int getFactor(int f2, int f3, int f5, int f7);

int getDigitFromMul(long long mul);

int getExp(long long n);

long long ex(int e);

int add(int factor, int f2, int f3, int f5, int f7);

long long getZeros(map<int, long long int> &factors);

class Key {
public:
    long long n;
    int exp;
    bool count0;

    bool operator<(const Key &other) const {
        if(count0 == other.count0) {
            if(exp == other.exp) {
                return n < other.n;
            }
            return exp < other.exp;
        }
        return count0;
    }
};

map<Key, map<int, long long>> cache;

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

    int t;
    long long n;
    cin >> t;

    for (int i = 0; i < t; i++) {
        cin >> n;

        int exp = getExp(n);
        map<int, long long> factors = count(n, exp, false, false);
        factors[getFactor(1, 0, 1, 0)]--;
        long long digits[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
        for (auto const &factor: factors) {
            int d = getDigit(factor.first);
            digits[d] += factor.second;
        }
        for (int i = 0; i < 10; i++) {
            if (i > 0) {
                cout << " ";
            }
            cout << digits[i];
        }

        cout << '\n';
    }

    return 0;
}

long long getZeros(map<int, long long int> &factors) {
    long long digits[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    for (auto const &factor: factors) {
        int d = getDigit(factor.first);
        digits[d] += factor.second;
    }
    return digits[0];
}

map<int, long long> count(long long n, int exp, bool count0, bool cach) {
    auto key = Key(n, exp, count0);
    auto it = cache.find(key);
    if(it != cache.end()) {
        return (*it).second;
    }

    map<int, long long> m;

    if (n <= 9 && exp==0) {
            if (n >= 0) m[getFactor(1, 0, 1, 0)]++;
            if (n >= 1) m[getFactor(0, 0, 0, 0)]++;
            if (n >= 2) m[getFactor(1, 0, 0, 0)]++;
            if (n >= 3) m[getFactor(0, 1, 0, 0)]++;
            if (n >= 4) m[getFactor(2, 0, 0, 0)]++;
            if (n >= 5) m[getFactor(0, 0, 1, 0)]++;
            if (n >= 6) m[getFactor(1, 1, 0, 0)]++;
            if (n >= 7) m[getFactor(0, 0, 0, 1)]++;
            if (n >= 8) m[getFactor(3, 0, 0, 0)]++;
            if (n >= 9) m[getFactor(0, 2, 0, 0)]++;
    } else {

        long long pattern = ex(exp);
        long long de = n / pattern;
        int digit = (int) de;

        long long lower = pattern - 1;
        map<int, long long> m2 = count(lower, exp - 1, false, true);
        map<int, long long> m3 = count(lower, exp - 1, true, true);
        map<int, long long> rest = count(n - (digit * pattern), exp - 1, true, false);

        if (digit > 0) {
            if (count0) {
                for (auto const &factor: m2) {
                    m[add(factor.first, 1, 0, 1, 0)] += factor.second;
                }
            } else {
                for (auto const &factor: m2) {
                    m[add(factor.first, 0, 0, 0, 0)] += factor.second;
                }
            }
        } else if (digit == 0) {
            if (count0) {
                for (auto const &factor: rest) {
                    m[add(factor.first, 1, 0, 1, 0)] += factor.second;
                }
            } else {
                for (auto const &factor: rest) {
                    m[add(factor.first, 0, 0, 0, 0)] += factor.second;
                }
            }
        }
        if (digit > 1) {
            for (auto const &factor: m3) {
                m[add(factor.first, 0, 0, 0, 0)] += factor.second;
            }
        } else if (digit == 1) {
            for (auto const &factor: rest) {
                m[add(factor.first, 0, 0, 0, 0)] += factor.second;
            }
        }
        if (digit > 2) {
            for (auto const &factor: m3) {
                m[add(factor.first, 1, 0, 0, 0)] += factor.second;
            }
        } else if (digit == 2) {
            for (auto const &factor: rest) {
                m[add(factor.first, 1, 0, 0, 0)] += factor.second;
            }
        }
        if (digit > 3) {
            for (auto const &factor: m3) {
                m[add(factor.first, 0, 1, 0, 0)] += factor.second;
            }
        } else if (digit == 3) {
            for (auto const &factor: rest) {
                m[add(factor.first, 0, 1, 0, 0)] += factor.second;
            }
        }
        if (digit > 4) {
            for (auto const &factor: m3) {
                m[add(factor.first, 2, 0, 0, 0)] += factor.second;
            }
        } else if (digit == 4) {
            for (auto const &factor: rest) {
                m[add(factor.first, 2, 0, 0, 0)] += factor.second;
            }
        }
        if (digit > 5) {
            for (auto const &factor: m3) {
                m[add(factor.first, 0, 0, 1, 0)] += factor.second;
            }
        } else if (digit == 5) {
            for (auto const &factor: rest) {
                m[add(factor.first, 0, 0, 1, 0)] += factor.second;
            }
        }
        if (digit > 6) {
            for (auto const &factor: m3) {
                m[add(factor.first, 1, 1, 0, 0)] += factor.second;
            }
        } else if (digit == 6) {
            for (auto const &factor: rest) {
                m[add(factor.first, 1, 1, 0, 0)] += factor.second;
            }
        }
        if (digit > 7) {
            for (auto const &factor: m3) {
                m[add(factor.first, 0, 0, 0, 1)] += factor.second;
            }
        } else if (digit == 7) {
            for (auto const &factor: rest) {
                m[add(factor.first, 0, 0, 0, 1)] += factor.second;
            }
        }
        if (digit > 8) {
            for (auto const &factor: m3) {
                m[add(factor.first, 3, 0, 0, 0)] += factor.second;
            }
        } else if (digit == 8) {
            for (auto const &factor: rest) {
                m[add(factor.first, 3, 0, 0, 0)] += factor.second;
            }
        }
        if (digit == 9) {
            for (auto const &factor: rest) {
                m[add(factor.first, 0, 2, 0, 0)] += factor.second;
            }
        }
    }

    if(cach) {
        cache[key] = m;
    }
    return m;
}

int getDigit(int factor) {
    int f2 = factor & 0xff;
    int f3 = (factor >> 8) & 0xff;
    int f5 = (factor >> 16) & 0xff;
    int f7 = (factor >> 24) & 0xff;

    long long mul = 1;
    for (int i = 0; i < f2; i++) {
        mul *= 2;
    }
    for (int i = 0; i < f3; i++) {
        mul *= 3;
    }
    for (int i = 0; i < f5; i++) {
        mul *= 5;
    }
    for (int i = 0; i < f7; i++) {
        mul *= 7;
    }

    return getDigitFromMul(mul);
}

int getDigitFromMul(long long mul) {
    while (mul > 9) {
        long long n = 1;
        while (mul > 0) {
            n *= mul % 10;
            mul /= 10;
        }
        mul = n;
    }

    return mul;
}

int getFactor(int f2, int f3, int f5, int f7) {
    return f2 | f3 << 8 | f5 << 16 | f7 << 24;
}

int add(int factor, int f2, int f3, int f5, int f7) {
    return factor + f2 + (f3 << 8) + (f5 << 16) + (f7 << 24);
}

int getExp(long long n) {
    int exp = -1;
    while (n > 0) {
        n /= 10;
        exp++;
    }

    return exp;
}

long long ex(int e) {
    long long res = 1;
    for (int i = 0; i < e; i++) {
        res *= 10;
    }

    return res;
}