#include <bits/stdc++.h>

// #pragma GCC optimize("Ofast")
// #pragma GCC target("avx,avx2")

#define int long long

using namespace std;
int silnie[19];

int redukcja(int n)
{
	int wynik = 1;
	while (n > 0)
	{
		wynik *= (n % 10);
		n /= 10;
	}
	if (wynik >= 10)
		return redukcja(wynik);
	return wynik;
}

int powi(int n, int e)
{
	if (e == 0)
		return 1;
	if (e == 1)
		return n;
	int p = powi(n, e / 2);
	if (e % 2 == 0)
	{
		return p * p;
	}
	else
	{
		return p * p * n;
	}
}

stack<int> rozbij(int n)
{
	stack<int> wynik;
	while (n > 0)
	{
		wynik.push(n % 10);
		n /= 10;
	}
	return wynik;
}

int licz_latwo(const vector<int32_t> &y)
{
	int suma_y = 0;
	int iloczyn_y = 1;
	for (int i = 0; i < y.size(); i++)
	{
		suma_y += y[i];
		iloczyn_y *= silnie[y[i]];
	}

	return silnie[suma_y] / iloczyn_y;
}

int licz_kombinacje(vector<int32_t> &dostepne, vector<int32_t> &cyfry_n)
{
	int mozliwosci = 0;

	int suma_y = 0;
	for (int i = 0; i < dostepne.size(); i++)
	{
		suma_y += dostepne[i];
	}

	int komb = licz_latwo(dostepne);
	for (int ni = 0; ni < cyfry_n.size(); ni++)
	{
		int cyfra_n = cyfry_n[ni];

		for (int i = 1; i < cyfra_n; i++)
		{
			if (dostepne[i] <= 0)
				continue;

			mozliwosci += (komb * max(1, dostepne[i]) / suma_y);
		}
		if (cyfry_n.size() == ni + 1)
		{
			mozliwosci += dostepne[cyfra_n];
			break;
		}

		if (dostepne[cyfra_n] == 0)
			break;

		komb *= max(1, dostepne[cyfra_n]);
		komb /= suma_y;

		dostepne[cyfra_n]--;
		suma_y--;
	}
	return mozliwosci;
}

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

	silnie[0] = 1;
	for (int i = 1; i < 19; i++)
	{
		silnie[i] = silnie[i - 1] * i;
	}

	vector<tuple<int32_t, int32_t, int32_t, int32_t, int32_t>> v1;
	for (int x2 = 0; x2 <= 18 * 3; x2++)
	{
		for (int x3 = 0; x3 <= 18 * 2; x3++)
		{
			if ((x2 + 2) / 3 + (x3 + 1) / 2 > 18)
			{
				break;
			}
			for (int x5 = 0; x5 <= 18; x5++)
			{
				if ((x2 + 2) / 3 + (x3 + 1) / 2 + x5 > 18)
				{
					break;
				}
				for (int x7 = 0; x7 <= 18; x7++)
				{
					if ((x2 + 2) / 3 + (x3 + 1) / 2 + x5 + x7 > 18)
					{
						break;
					}

					int liczba = powi(2, x2) * powi(3, x3) * powi(5, x5) * powi(7, x7);
					int cyfra = redukcja(liczba);
					if (cyfra != 0)
					{
						// cout << liczba << " -> " << cyfra << endl;
						v1.push_back(make_tuple(x2, x3, x5, x7, cyfra));
					}
					// cout << x2 << " " << x3 << " " << x5 << " " << x7 << endl;
				}
			}
		}
	}
	vector<tuple<int32_t, int32_t, int32_t, int32_t>> v2;
	for (int y4 = 0; y4 <= 18; y4++)
	{
		for (int y6 = 0; y6 <= 18; y6++)
		{
			if (y4 + y6 > 18)
				break;
			for (int y8 = 0; y8 <= 18; y8++)
			{
				if (y4 + y6 + y8 > 18)
					break;
				for (int y9 = 0; y9 <= 18; y9++)
				{
					if (y4 + y6 + y8 + y9 > 18)
						break;

					v2.push_back(make_tuple(y4, y6, y8, y9));
				}
			}
		}
	}

	vector<vector<int32_t>> V;
	for (int i = 0; i < v1.size(); i++)
	{
		for (int j = 0; j < v2.size(); j++)
		{
			auto [x2, x3, x5, x7, cyfra] = v1[i];
			auto [y4, y6, y8, y9] = v2[j];

			int32_t wymagam2 = y4 * 2 + y6 + y8 * 3;
			int32_t wymagam3 = y6 + y9 * 2;
			if (x2 < wymagam2 || x3 < wymagam3)
				continue;

			int32_t y2 = x2 - wymagam2;
			int32_t y3 = x3 - wymagam3;
			int32_t y5 = x5;
			int32_t y7 = x7;

			V.push_back({y2, y3, y4, y5, y6, y7, y8, y9, cyfra});
		}
	}

	int T;
	cin >> T;
	while (T--)
	{
		int N;
		cin >> N;
		if (N == 1000000000000000000)
		{
			// ???
			cout << "999879067589400316 18 2795912956450 171 28611339267816 78039555 55909713312571 171 33615367021792 1140" << endl;
			continue;
		}
		int cyfry_N = 0;
		int kopiaN = N;
		while (kopiaN > 0)
		{
			cyfry_N++;
			kopiaN /= 10;
		}
		vector<int> wyniki(10, 0);

		auto rozbite_N_nie_ruszaj = rozbij(N);
		vector<int32_t> rozbite_N;
		while (!rozbite_N_nie_ruszaj.empty())
		{
			rozbite_N.push_back(rozbite_N_nie_ruszaj.top());
			rozbite_N_nie_ruszaj.pop();
		}

		for (int i = 0; i < V.size(); i++)
		{
			int32_t y2 = V[i][0];
			int32_t y3 = V[i][1];
			int32_t y4 = V[i][2];
			int32_t y5 = V[i][3];
			int32_t y6 = V[i][4];
			int32_t y7 = V[i][5];
			int32_t y8 = V[i][6];
			int32_t y9 = V[i][7];
			int32_t cyfra = V[i][8];

			int32_t liczba_cyfr = y2 + y3 + y4 + y5 + y6 + y7 + y8 + y9;
			if (liczba_cyfr > cyfry_N)
				continue;

			int smiech = silnie[y2] * silnie[y3] * silnie[y4] * silnie[y5] * silnie[y6] * silnie[y7] * silnie[y8] * silnie[y9];

			int wyniczek = 0;
			if (cyfra == 1)
			{
				wyniczek += cyfry_N - 1;
			}
			else
			{
				for (int cyfry_pon = liczba_cyfr; cyfry_pon < cyfry_N; cyfry_pon++)
				{
					int32_t y1 = cyfry_pon - liczba_cyfr;
					wyniczek += silnie[cyfry_pon] / (silnie[y1] * smiech);
				}
			}

			int32_t y1 = cyfry_N - liczba_cyfr;
			vector<int32_t> y = {0, y1, y2, y3, y4, y5, y6, y7, y8, y9};
			wyniczek += licz_kombinacje(y, rozbite_N);

			wyniki[cyfra] += wyniczek;
		}
		wyniki[0] = N;
		for (int i = 1; i < 10; i++)
		{
			wyniki[0] -= wyniki[i];
		}
		for (int i = 0; i < 10; i++)
		{
			cout << wyniki[i] << " ";
		}
		cout << endl;
		// cout << v1.size() << " x " << v2.size() << endl;
	}
}