#include <bits/stdc++.h>

using namespace std;

vector<vector<int>> results_cached;
vector<vector<vector<int>>> permutations;

vector<long long> factorials;
vector<long long> powers10;
vector<long long> powers9;

void fill_digit_counts(vector<int> &result, long long number)
{
    fill(result.begin(), result.end(), 0);

    int digit;
    while (number > 0)
    {
        digit = number % 10;
        ++result[digit];
        number /= 10;
    }
}

long long play(long long x)
{
    while (x >= 10)
    {
        long long product = 1;
        long long temp = x;

        while (temp > 0)
        {
            product *= (temp % 10);
            temp /= 10;
        }

        x = product;
    }
    return x;
}

long long play(vector<int> &kombination)
{
    long long x = 1;
    int temp;

    for(int i=9; i>=0; i--)
    {
        temp=kombination[i];
        while(temp--)
        {
            x = 10*x + i;
        }
    }

    return play(x);

}

int count_digits(long long number)
{
    int result = 1;

    while(number >= 10)
    {
        ++result;
        number /= 10;
    }

    return result;
}

long long naive_count_zeros(long long start, long long border)
{
    long long temp;
    long long result = 0;
    for(start; start<border; start++)
    {
        temp = start;
        while(temp > 0)
        {
            if(temp % 10 == 0) { ++result; break; }
            temp /= 10;
        }
    }
    return result;
}

long long count_zeros(long long start, long long border)
{
    // zakladamy border = start + shift

    if(border - start < 10)
    {
        return naive_count_zeros(start, border);
    }

    long long diff = border - start;
    int digits = count_digits(diff);

    long long without_zeros = powers9[digits-1];

    return diff - without_zeros;
}

void generate_permutations(int max_digits_num)
{
    permutations.resize(max_digits_num+1);

    int tab_pom[] = { 1, 9, 45, 165, 495, 1287, 3003, 6435, 12870, 24310, 43758, 75582, 125970, 203490, 319770, 490314, 735471, 1081575, 1562275, 2220075 };

    for(int i=0; i<permutations.size(); i++)
    {
        permutations[i].resize(tab_pom[i], vector<int> (10, 0));
    }

    vector<int> indexes(20, 0);
    int actual_digits_count1=0;
    int actual_digits_count2=0;
    int actual_digits_count3=0;
    int actual_digits_count4=0;
    int actual_digits_count5=0;
    int actual_digits_count6=0;
    int actual_digits_count7=0;
    int actual_digits_count8=0;
    int actual_digits_count9=0;
    for(int num1=0; num1<=max_digits_num; num1++)
    {
        actual_digits_count1 = num1;
        for(int num2=0; num2<=max_digits_num; num2++)
        {
            if(actual_digits_count1+num2 > max_digits_num) { break; }
            actual_digits_count2 = actual_digits_count1+num2;
            for(int num3=0; num3<=max_digits_num; num3++)
            {
                if(actual_digits_count2+num3 > max_digits_num) { break; }
                actual_digits_count3 = actual_digits_count2+num3;
                for(int num4=0; num4<=max_digits_num; num4++)
                {
                    if(actual_digits_count3+num4 > max_digits_num) { break; }
                    actual_digits_count4 = actual_digits_count3+num4;
                    for(int num5=0; num5<=max_digits_num; num5++)
                    {
                        if(actual_digits_count4+num5 > max_digits_num) { break; }
                        actual_digits_count5 = actual_digits_count4+num5;
                        for(int num6=0; num6<=max_digits_num; num6++)
                        {
                            if(actual_digits_count5+num6 > max_digits_num) { break; }
                            actual_digits_count6 = actual_digits_count5+num6;
                            for(int num7=0; num7<=max_digits_num; num7++)
                            {
                                if(actual_digits_count6+num7 > max_digits_num) { break; }
                                actual_digits_count7 = actual_digits_count6+num7;
                                for(int num8=0; num8<=max_digits_num; num8++)
                                {
                                    if(actual_digits_count7+num8 > max_digits_num) { break; }
                                    actual_digits_count8 = actual_digits_count7+num8;
                                    for(int num9=0; num9<=max_digits_num; num9++)
                                    {
                                        if(actual_digits_count8+num9 > max_digits_num) { break; }
                                        actual_digits_count9 = actual_digits_count8+num9;

                                        //if(actual_digits_count9 >= permutations.size()) { cout << actual_digits_count9 << " wyszlo1" << endl; }
                                        //if(indexes[actual_digits_count9] >= permutations[actual_digits_count9].size()) { cout << indexes[actual_digits_count9] << " " << permutations[actual_digits_count9].size() << " wyszlo2" << endl; }
                                        permutations[actual_digits_count9][indexes[actual_digits_count9]] = { 0, num1, num2, num3, num4, num5, num6, num7, num8, num9 };
                                        ++indexes[actual_digits_count9];
                                        //cout << "przypisalo " << actual_digits_count9 << endl;
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}

long long naive_frequency(long long start, long long border, vector<int> &kombination)
{
    long long result = 0;
    long long temp;
    bool pom;
    vector<int> curr_komb(10);
    for(long long i=start; i<border; i+=1)
    {
        temp = i;
        fill(curr_komb.begin(), curr_komb.end(), 0);
        pom = true;
        while(temp >= 1)
        {
            ++curr_komb[temp%10];
            temp /= 10;
        }

        for(int j=0; j<10; j++)
        {
            pom = pom && curr_komb[j] == kombination[j];
        }

        result += (int)pom;
    }
    return result;
}

void print_vec(vector<int> &vec)
{
    for(int i=0; i<vec.size(); i++)
    {
        cout << vec[i] << " ";
    }
    cout << endl;
}

long long frequency(long long start, long long border, vector<int> &kombination, vector<int> &counted_fixed_digits)
{
    if(border - start < 10)
    {
        return naive_frequency(start, border, kombination);
    }

    int digits_num = count_digits(start) - 1;

    long long result = factorials[digits_num];

    result /= factorials[max(kombination[0] - counted_fixed_digits[0], 0)];
    for(int i=1; i<10; i++)
    {
        if(kombination[i] < counted_fixed_digits[i]) { return 0; }
        result /= factorials[kombination[i] - counted_fixed_digits[i]];
    }

    /*if(result==0) {
            cout << "jaja" << endl;
            print_vec(kombination);
            print_vec(counted_fixed_digits);
    }*/


    return result;
}

void merge_results(vector<int> &result1, vector<int> &result2)
{
    for(int i=0; i<result1.size(); i++)
    {
        result1[i] += result2[i];
    }
}

bool isZeroVector(const vector<int>& vec)
{
    return all_of(vec.begin(), vec.end(), [](int x) { return x == 0; });
}

int findX(const vector<vector<int>>& vecs)
{
    int left = 0, right = vecs.size() - 1, mid, x = vecs.size();

    while (left <= right)
    {
        mid = (left + right) / 2;
        if (isZeroVector(vecs[mid]))
        {
            x = mid;
            right = mid - 1;
        }
        else
        {
            left = mid + 1;
        }
    }

    return x;
}

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

    factorials.resize(20, 1);
    for(int i=2; i<factorials.size(); i++)
    {
        factorials[i] = factorials[i-1] * i;
    }
    powers10.resize(20, 1);
    powers9.resize(20, 1);
    for(int i=1; i<powers10.size(); i++)
    {
        powers10[i] = powers10[i-1] * 10;
        powers9[i] = powers9[i-1] * 9;
    }

    /*cout << naive_count_zeros(575670, 575671) << " " << count_zeros(575670, 575671) << endl;
    cout << naive_count_zeros(1100, 1200) << " " << count_zeros(1100, 1200) << endl;
    cout << naive_count_zeros(375000, 376000) << " " << count_zeros(375000, 376000) << endl;*/

    /*long long start = 100000;
    long long border = 2 * start;
    vector<int> test_vec { 2, 3, 0, 1, 0, 0, 0, 0, 0, 0 };
    vector<int> test_vec2 { 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 };

    vector<int> test_vec3 { 0, 3, 0, 1, 0, 0, 0, 0, 1, 0 };

    cout << play(test_vec3) << endl;*/
    /*cout << "digits num: " << count_digits(start) << endl;
    cout << "vec sum: " << std::accumulate(test_vec.begin(), test_vec.end(), 0) << endl;
    cout << "naive(real): " << naive_frequency(start, border, test_vec) << endl;
    cout << "calculated:  " << frequency(start, border, test_vec, test_vec2) << endl;*/

    const long long OPTIMIZATION_BORDER1 = 10000LL;
    const long long OPTIMIZATION_BORDER2 = 10000000000000LL;
    const long long BIGGEST_NUMBER = 1000000000000000000LL;

    long long the_biggest=0;

    int big_numbers_count = 0;
    int results_cached_iter = 0;

    int t;
    cin>>t;

    vector<long long> numbers(t);

    for (int i = 0; i < t; i++)
    {
        cin>>numbers[i];

        big_numbers_count += (int)(numbers[i] >= OPTIMIZATION_BORDER2);

        the_biggest = max(numbers[i], the_biggest);
    }

    if(big_numbers_count >= 2 || true)
    {
        int digits = count_digits(the_biggest);

        generate_permutations(digits);

        results_cached.resize((int)(the_biggest/OPTIMIZATION_BORDER2)+1, vector<int>(10,0));

        results_cached_iter = 0;

        // tu moze zliczanie tych wynikow dla 10**13 itd...
    }

    /*for(int i=0; i<permutations[1].size(); i++)
    {
        for(int j=0; j<10; j++)
        {
            cout << permutations[1][i][j] << " ";
        }
        cout << endl;
    }

    cout << "dla digit count = 2:" << endl;

    for(int i=0; i<permutations[2].size(); i++)
    {
        for(int j=0; j<10; j++)
        {
            cout << permutations[2][i][j] << " ";
        }
        cout << endl;
    }

    cout << "KONIEC PERMUTACJI" << endl;*/

    vector<int> result(10);

    long long start_counting = 0;

    for(int i=0; i<numbers.size(); i++)
    {
        fill(result.begin(), result.end(), 0);

        if(numbers[i] >= OPTIMIZATION_BORDER2 && big_numbers_count >= 2)
        {
            // szukamy prekalkulowanych, mozliwe ze binary search
            // potem frequency dla mniejszych niz optimizationborder2
            // jazda

            // tu po prostu trzeba sobie pozapisywac wyniki poprzednie i na ich bazie i to nawet nie bylby osobny if, tyko w sumie to co chcialem zrobic jako ulepszony brute force

            // szukanie czy jakis results_cached jest != {0} i przypisanie wyniku z niego i startowanie z punktu

            int index = findX(results_cached);

            result.assign(results_cached[index].begin(), results_cached[index].end());

            start_counting = OPTIMIZATION_BORDER2 * (index + 1);
        }
        if(numbers[i] > OPTIMIZATION_BORDER1 && false)
        {
            long long number_of_plays_ends_with;
            int end_digit, curr_digit_count;

            long long current_num = start_counting;
            int number_digit_count = count_digits(start_counting);
            long long shift = powers10[number_digit_count - 1];

            while(start_counting + shift > numbers[i] && shift > 1)
            {
                shift /= 10;
            }

            long long curr_border = current_num + shift;

            long long naive_freq_result;

            vector<int> fixed_digits(10, 0);

            int global_iteration = 0;
            int cnt_while = 0;

            while(current_num <= numbers[i])
            {
                curr_digit_count = count_digits(current_num);

                if(current_num == powers10[curr_digit_count-1])
                {
                    shift = current_num;

                    while(current_num + shift > numbers[i])
                    {
                        //cout << curr_border + shift << " "<<  numbers[i] << endl;
                        shift /= 10;
                    }
                    if(shift == 0) { break; }
                    //curr_border = current_num + shift;
                }
                cout << "shift: " << shift << endl;
                for(int combination=0; combination < permutations[curr_digit_count].size(); combination++)
                {
                    fill_digit_counts(fixed_digits, current_num);
                    end_digit = play(permutations[curr_digit_count][combination]);
                    number_of_plays_ends_with = frequency(current_num, curr_border, permutations[curr_digit_count][combination], fixed_digits);

                    naive_freq_result = naive_frequency(current_num, curr_border, permutations[curr_digit_count][combination]);
                    if(naive_freq_result != number_of_plays_ends_with)
                    {
                        cout << "nie zgadza sie naive(real): " << naive_freq_result << " wyliczone: " << number_of_plays_ends_with << endl;
                        cout << "poczatek: " << current_num << " koniec: " << curr_border << endl;
                    }
                    result[end_digit] += number_of_plays_ends_with;

                    ++global_iteration;

                    //if(combination % 1000 == 0) { cout << combination << endl; }
                }
                long long zeros = count_zeros(current_num, curr_border);
                result[0] += count_zeros(current_num, curr_border);

                long long zeros_naive = naive_count_zeros(current_num, curr_border);
                if(zeros_naive != zeros)
                {
                    cout << "nie zgadza sie naive(real) zeros: " << zeros_naive << " wyliczone: " << zeros << endl;
                    cout << "poczatek: " << current_num << " koniec: " << curr_border << endl;
                }

                if(current_num != 0 && (current_num % OPTIMIZATION_BORDER2) == 0 && isZeroVector(results_cached[results_cached_iter]))
                {
                    results_cached[results_cached_iter].assign(result.begin(), result.end());
                    ++results_cached_iter;
                }

                while(curr_border + shift > numbers[i])
                {
                    //cout << curr_border + shift << " "<<  numbers[i] << endl;
                    shift /= 10;
                }
                if(shift == 0) { break; }
                current_num += shift;
                curr_border += shift;

                ++cnt_while;
            }
            ++result[play(numbers[i])];

            //cout << "global iterations: " << global_iteration << endl;
            //cout << "while iterations: " <<cnt_while << endl;
        }
        else
        {
            fill(result.begin(), result.end(), 0);
            for(long long j=1; j<=numbers[i]; j++)
            {
                ++result[play(j)];
            }
        }

        printf("%d %d %d %d %d %d %d %d %d %d\n", result[0], result[1], result[2], result[3], result[4], result[5], result[6], result[7], result[8], result[9]);
    }
    return 0;
}