#include <cstdio>
#include <cstdlib>
#include <cassert>
#include <cstring>

#include <array>
#include <vector>

using llu = long long unsigned int;
using histogram_t = std::array<llu, 10>;

static const llu POWERS_OF_TEN[] = {
    1ULL,
    10ULL,
    100ULL,
    1000ULL,
    10000ULL,
    100000ULL,
    1000000ULL,
    10000000ULL,
    100000000ULL,
    1000000000ULL,
    10000000000ULL,
    100000000000ULL,
    1000000000000ULL,
    10000000000000ULL,
    100000000000000ULL,
    1000000000000000ULL,
    10000000000000000ULL,
    100000000000000000ULL,
    1000000000000000000ULL,
};

static llu BINOM[20][20];

// TODO: Precompute this
llu binom(llu n, llu k) {
    if (k > n) {
        return 0;
    }
    if (2 * k > n) {
        return binom(n, n - k);
    }
    if (k == 0) {
        return 1;
    }
    return binom(n - 1, k - 1) * n / k;
}

int play(llu num) {
    while (num >= 10) {
        llu new_num = 1;
        while (num > 0) {
            new_num *= (num % 10);
            num /= 10;
        }
        num = new_num;
    }
    return num;
}

void enumerate(std::array<std::vector<histogram_t>, 10>& result, histogram_t& histogram, int idx, int prev_digit) {
    if (idx == 0) {
        llu num = 0;
        for (int i = 1; i < 10; i++) {
            for (int j = 0; j < histogram[i]; j++) {
                num = 10 * num + (llu)i;
            }
        }
        int play_result = play(num);
        if (play_result != 0) {
            result[play_result].push_back(histogram);
        }
        return;
    }
    for (int d = prev_digit; d < 10; d++) {
        if (d % 2 == 0 && histogram[5] > 0) {
            continue;
        }
        if (d == 5 && (histogram[2] > 0 || histogram[4] > 0)) { 
            continue;
        }

        histogram[d]++;
        enumerate(result, histogram, idx - 1, d);
        histogram[d]--;
    }
}

histogram_t compute(std::array<std::vector<histogram_t>, 10> precomputed, llu upto) {
    histogram_t ret = {{0}};

    char digits[32];
    sprintf(digits, "%llu", upto);
    int len = std::strlen(digits);

    for (int i = 0; i < len; i++) {
        // printf("Position %d (%c)\n", i, digits[i]);
        digits[i] -= '0';

        // For all non-zero digits up to the current one, count the configurations
        // which start with 'd'
        for (int d = 1; d < digits[i]; d++) {
            // printf("Processing digit %d\n", d);
            for (int remainder = 1; remainder < 10; remainder++) {
                const auto& histos = precomputed[remainder];
                for (const histogram_t& histo : histos) {
                    if (histo[d] > 0) {
                        // printf("  Including");
                        // for (int i = 0; i < 10; i++) {
                        //     printf(" %llu", histo[i]);
                        // }
                        // printf("\n");
                        llu counts = 1;
                        llu sum = 0;
                        for (int x = 1; x < 10; x++) {
                            sum += histo[x] - (x == d ? 1 : 0);
                            counts *= BINOM[sum][histo[x] - (x == d ? 1 : 0)];
                        }
                        ret[remainder] += counts;
                    }
                }
            }
        }

        // Filter out the histograms - leave only those which are possible
        // after the current digit is added
        // printf("Continuing to the next digit (%d)\n", digits[i]);
        for (auto& histos : precomputed) {
            int pos = 0;
            while (pos < histos.size()) {
                if (histos[pos][digits[i]] == 0) {
                    // Remove this histogram - doesn't have the necessary digits
                    // printf("  Rejecting");
                    // for (int x = 0; x < 10; x++) {
                    //     printf(" %llu", histos[pos][x]);
                    // }
                    // printf("\n");
                    histos[pos] = histos.back();
                    histos.pop_back();
                } else {
                    // printf("  Keeping  ");
                    // for (int i = 0; i < 10; i++) {
                    //     printf(" %llu", histos[pos][i]);
                    // }
                    // printf("\n");
                    histos[pos][digits[i]]--;
                    pos++;
                }
            }
        }
    }

    // There might be one remaining histogram that we need to include
    for (int i = 1; i < 10; i++) {
        if (!precomputed[i].empty()) {
            // printf("Adding leftover histogram with remainder %d\n", i);
            ret[i]++;
        }
    }

    ret[0] = upto + 1 - POWERS_OF_TEN[len - 1];
    for (int i = 1; i < 10; i++) {
        ret[0] -= ret[i];
    }

    return ret;
};

int main() {
    for (int n = 0; n < 20; n++) {
        for (int k = 0; k < 20; k++) {
            BINOM[n][k] = binom(n, k);
        }
    }

    int t;
    scanf("%d\n", &t);

    std::array<std::array<std::vector<histogram_t>, 10>, 20> precomputed;
    std::array<histogram_t, 20> baselines = {{0}};

    for (int i = 1; i < 20; i++) {
        histogram_t tmp;
        enumerate(precomputed[i], tmp, i, 1);
    }

    llu tenpow = 1;
    for (int i = 1; i < 20; i++) {
        baselines[i] = compute(precomputed[i - 1], tenpow - 1);
        for (int j = 0; j < 10; j++) {
            baselines[i][j] += baselines[i - 1][j];
        }
        tenpow *= 10;
    }

    while (t --> 0) {
        llu n;
        scanf("%llu", &n);

        char digits[32];
        sprintf(digits, "%llu", n);
        int len = std::strlen(digits);

        histogram_t counts = compute(precomputed[len], n);
        for (int i = 0; i < 10; i++) {
            if (i == 9) {
                printf("%llu\n", baselines[len][i] + counts[i]);
            } else {
                printf("%llu ", baselines[len][i] + counts[i]);
            }
        }
    }

    return 0;
}