#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned ll
#define pb push_back
#define pii pair<int,int>
#define pl pair<ll,ll>
#define F first
#define S second
#define pq priority_queue
#define rep(x,y) for(ull x = 0; x < y; x++)
#define all(x) x.begin(), x.end()
#define deb(x) if(debug) cout << #x << " = " << x << '\n';
#define deb2(x,y) if(debug) cout << #x << " = " << x << ", " << #y << " = " << y << '\n';

constexpr ull M = 1e6+7;
constexpr int N = 1e6+7;
constexpr int C = 10;			
constexpr bool debug = 0;

map<ull,ull> where;		//do ktorej cyfry trafia liczby z tym iloczynem
map<ull,ull> combo;		//[hasz] = liczba kombinacji
ull maks, cyfrmaks; 
ull sc[10];
ull fac[20];
ull Cpow[13];
int q;

struct que{
	ull ind;
	ull num;
	ull ans[10];
};

bool numsort(que a, que b){
	return a.num < b.num;
}

bool indsort(que a, que b){
	return a.ind > b.ind;
}


int goes(ull num){			//raczej dziala
	if(num < 10){
		where[num] = num+1;
		return where[num]-1;
	}
	if(where[num] > 0) return where[num]-1;
	ull i = 1;
	while(num > 0){
		i *= num%10;
		num /= 10;
	}
	where[num] = goes(i)+1;
	return where[num]-1;
}


ull calc_comb(ull hasz){		//sprawdzic
	if(combo[hasz] == 0){
		ull obcomb = 0;
		ull bob = 1;
		for(ull i = 0; i < 8; i++){
			if((hasz/bob)%C > 0){
				obcomb += calc_comb(hasz-bob);
			} 
			bob *= C;
		}
		combo[hasz] = obcomb;
		return obcomb;
	}
	return combo[hasz];
}

ull haszuj(vector<ull> kk){
	ull hasz = 0;
	ull ob = 1;
	for(ull i = 0; i < 8; i++){
		hasz += ob*kk[i];
		ob *= C;
	}
	return hasz;
}

vector<ull> unhaszuj(ull hasz){
	vector<ull> unhasz(8);
	for(ull i = 0; i < 8; i++){
		unhasz[i] = hasz%C;
		hasz /= C;
	}
	return unhasz;
}

ull choos(ull a, ull b){			//a wybierz b
	if(a < b) return 0;
	return fac[a]/(fac[b]*fac[a-b]);
}

void process(vector<ull> nums){	//zakladamy, ze przerobilismy wszystkie podciagi
	ull obhasz = haszuj(nums);
	ull kombs = 0;
	ull obkombs = calc_comb(obhasz);

	//for(auto k: nums) cout << k << ' ';
	if(debug) cout << '\n';

	ull cyfr = 0;
	for(auto k: nums) cyfr += k;

	//mniejsza ilosc cyfr
	//deb(cyfr);

	if(cyfr == 0) return;

	for(ull i = cyfr; i < cyfrmaks; i++){
		kombs += obkombs*choos(i,cyfr);
	}
	//deb(kombs);


	//rowna ilosc cyfr, idzie po prefiksach
	ull hasz2 = obhasz;

	ull ex = 0;
	ull cyf = 2;


	ull ten = 1;				
	while(obhasz > 0){			//to raczej dziala
		while(obhasz%C){
			ex += ten*cyf;
			ten *= 10;
			--obhasz;
		}
		obhasz /= C;
		++cyf;
	}
	ten = pow(10,cyfrmaks-1);
	ull cel = goes(ex);
	ull rem = cyfrmaks-1;
	ull cyfr2 = cyfr;

	deb(ex);
	deb(cel);

	while(ten > 0){							
		for(int i = 1; i < (maks/ten)%10; i++){				//co jesli zero?
			deb(i);
			if(i == 1){
				kombs += calc_comb(hasz2)*choos(rem,cyfr2);
			}
			else if((hasz2/Cpow[i-2])%C >= 1){
				//cout << "BAM " << rem << ' ' << cyfr2 << '\n';
				
				kombs += calc_comb(hasz2-Cpow[i-2])*choos(rem,cyfr2-1);
			}
		}

		if((maks/ten)%10 != 1){
			if((maks/ten)%10 == 0) break;
			if( (hasz2/Cpow[((maks/ten)%10)-2])%C >= 1){
				hasz2 -= Cpow[((maks/ten)%10)-2];
				cyfr2--;
				if(cyfr2 < 0) break;
			}
			else break;
		}
		ten /= 10;
		rem--;
		//if(rem < cyfr2) break;
	}


	deb(kombs);

	

	//deb(ex);

	sc[cel] += kombs;
}

que solve(){		//musimy policzyc potencjalne grupy
	fill(sc, sc+10, 0);
	cyfrmaks = 0;
	ull low = 1;
	if(maks % 10 == 0){
		sc[0]++;
		maks--;
	}
	while(low <= maks){			//ile cyfr ma maks
		low *= 10;
		cyfrmaks++;
	}

	
	deb(cyfrmaks);

	//process({0,2,1,3,1,1,0,1});

	//ile idzie do 0
	

	bool ones = 1;
	ull tochek = maks;
	while(tochek > 0){
		if(tochek%10 == 0){
			ones = 1;
			break;
		}
		else if(tochek%10 != 1){
			ones = 0;
			//break;
		}
		tochek /= 10;
	}
	if(!ones){
		sc[goes(maks)]++;
	}

	ull nonz = 0;
	ull ten = pow(10,cyfrmaks-1);
	ull nin = pow(9, cyfrmaks-1);
	bool pref = 1;
	if(nin == 1) nonz = maks;
	else{
		while(nin > 0){
			if(nin > 1) nonz += nin;
			deb(nonz);								//mniej cyfr, doliczamy ostatni
			if((maks/ten)%10 == 0) pref = 0;
			if(pref) nonz += ((maks/ten)%10 - 1)*nin;				//uzywamy wszystkich cyfr, skipujemy ostatni element?
			if(pref && nin == 1) nonz++;
			deb(nin);
			ten /= 10;
			nin /= 9;

		}
	}

	deb(nonz);
	//ile to ciagi jedynek
	ull ons = 1;
	while(ons <= maks){
		sc[1]++;
		ons = ons*10 + 1;
	}


	//deb(nonz);
	sc[0] += maks-nonz;
	rep(k9, cyfrmaks+1){
		rep(k8, cyfrmaks+1-k9){
			rep(k7, cyfrmaks+1-k9-k8){
				rep(k6, cyfrmaks+1-k9-k8-k7){
				//for(int k5 = 0; k5 <= 0; k5++){
					rep(k5, cyfrmaks+1-k9-k8-k7-k6){
						rep(k4, cyfrmaks+1-k9-k8-k7-k6-k5){
							rep(k3, cyfrmaks+1-k9-k8-k7-k6-k5-k4){
								rep(k2, cyfrmaks+1-k9-k8-k7-k6-k5-k4-k3){
									vector<ull> nums = {k2,k3,k4,k5,k6,k7,k8,k9};
									process(nums);
								}
							}
						}
					}
				}
			}
		}
	}
	
	que ok;
	ok.ind = q;
	for(int i = 0; i < 10; i++){
		ok.ans[i] = sc[i];
	}
	return ok;
	//cout << '\n';
	
}

int main(){
	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	combo[0] = 1;
	fac[0] = 1;
	Cpow[0] = 1;
 	for(ull i = 1; i < 20; i++) fac[i] = fac[i-1]*i;
 	for(ull i = 1; i < 20; i++) Cpow[i] = Cpow[i-1]*C;

 	//cout << calc_comb(haszuj({2,2,0,0,0,0,0,0}));
	//rep(i,11) deb(choos(10,i));

 	vector<que> quers, quers2;

	cin >> q;
	while(q--){
		cin >> maks;

		//cout << q << ' ' << maks << '\n';
		if(maks <= M){
			que ok;
			ok.ind = q;
			ok.num = maks;
			quers.pb(ok);
		}
		else{
			que ok = solve();
			quers2.pb(ok);
		}
	}
	
	if(!quers.empty()){
		fill(sc, sc+10, 0);
		//cout << "don";

		sort(all(quers), numsort);
		ull number = 0;
		for(ull i = 1; i <= M; i++){
			//cout << i << '\n';
			//cout << number << '\n';

			sc[goes(i)]++;
			while(i == quers[number].num){
				for(int j = 0; j < 10; j++){
					quers[number].ans[j] = sc[j];
				}
				number++;
				if(number >= quers.size()) break;
			}
			if(number >= quers.size()) break;
		}
	}
	if(quers.empty()) quers = quers2;
	else quers.insert(quers.end(), quers2.begin(), quers2.end());
	sort(all(quers), indsort);

	for(auto k: quers){
		for(int i = 0; i < 10; i++) cout << k.ans[i] << ' ';
		cout << '\n';
	}
	/*
	*/
	
	return 0;
}