#include <iostream>
#include <vector>
#include <cstdlib>
#include <algorithm>
#include <iomanip>
#include <cassert>
#include <map>

struct ShortNode
{
  unsigned long long numer;
  int pozycja;
};

void generateShortNodes(long long currentPower, std::vector<int> primes, unsigned long long n, std::vector<ShortNode> & result)
{
  int prime = primes.back();
  std::vector<int> new_primes = primes;
  new_primes.pop_back();
  for (unsigned long long power = currentPower; power < n; power *= prime)
  {
    if (new_primes.size() > 0)
      generateShortNodes(power, new_primes, n, result);
    else
    {
      ShortNode node;
      node.numer = power;
      node.pozycja = -1;
      result.push_back(node);
    }
  }
}

const static int MAX_DLUGOSC = 20;
const static int LICZBA_CYFR = 10;

struct Node
{
  ShortNode shortNode;
  unsigned long long korzen;
  ShortNode pochodne[LICZBA_CYFR];
  unsigned long long liczbaSynowDlugosc[MAX_DLUGOSC];
};

unsigned long long wynikMnozenia(unsigned long long liczba)
{
  unsigned long long wynik = 1;
  unsigned long long  wynikDzielenia = -1;
  if (liczba<=9)
    return liczba;
  do 
  {
    wynikDzielenia = liczba / 10;
    int ostaniaCyfra = liczba - wynikDzielenia * 10;
    wynik *= ostaniaCyfra;
    liczba = wynikDzielenia;
  } while (liczba > 9);
  return wynik * liczba;
}

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

  int t;
  std::cin >> t;
  std::vector<unsigned long long> granice;
  for (int i = 0; i < t; ++i)
  {
    unsigned long long granica;
    std::cin >> granica;
    granice.push_back(granica);
  }
  std::vector<unsigned long long> sorted_granice = granice;

  std::sort(sorted_granice.begin(), sorted_granice.end());

  unsigned long long n = sorted_granice.back() + 1;

  std::vector<ShortNode> shortNodes;
  ShortNode zeroNode;
  zeroNode.numer = 0;
  zeroNode.pozycja  = -1;
  shortNodes.push_back(zeroNode);
  generateShortNodes(1, { 2, 3, 5, 7 }, n, shortNodes);
  std::sort(shortNodes.begin(), shortNodes.end(), [](const ShortNode& lhs, const ShortNode& rhs)
    {
      return lhs.numer < rhs.numer;
    });
  std::map<unsigned long long, ShortNode> shortNodesMap;
  for (int i = 0; i < shortNodes.size(); ++i)
  {
    shortNodes[i].pozycja = i;
    shortNodesMap[shortNodes[i].numer] = shortNodes[i];
  }
  std::vector<Node> nodes;
  for (int i = 0; i < shortNodes.size(); ++i)
  {
    Node node;
    node.shortNode = shortNodes[i];
    for (int d = 0; d < MAX_DLUGOSC; ++d)
    {
      node.liczbaSynowDlugosc[d] = 0;
    }
    for (int c = 0; c < LICZBA_CYFR; ++c)
    {
      unsigned long long numerPochodny = node.shortNode.numer * c;
      if (shortNodesMap.count(numerPochodny) > 0)
      {
        node.pochodne[c] = shortNodesMap[numerPochodny];
      }
      else
      {
        node.pochodne[c].numer = 0;
        node.pochodne[c].pozycja = -1;
      }
    }
    nodes.push_back(node);
  }
  for (int i = 0; i < LICZBA_CYFR; ++i)
  {
    assert(nodes[i].shortNode.numer == i);
    nodes[i].korzen = i;
  }
  for (int i = 0; i < nodes.size(); ++i)
  {
    unsigned long long numerOjca = wynikMnozenia(nodes[i].shortNode.numer);
    assert(shortNodesMap.count(numerOjca) > 0);
    ShortNode ojciec = shortNodesMap[numerOjca];
    nodes[i].korzen = nodes[ojciec.pozycja].korzen;
  }

  for (int i = 0; i < LICZBA_CYFR; ++i)
  {
    assert(nodes[i].shortNode.numer == i);
    nodes[i].liczbaSynowDlugosc[1] = 1;

  }

  for (int d=2; d<MAX_DLUGOSC; ++d)
  {
    for (int i = 0; i < nodes.size(); ++i)
    {
      for (int c = 1; c < LICZBA_CYFR; ++c)
      {
        int pozycjaPochodnej = nodes[i].pochodne[c].pozycja;
        if (pozycjaPochodnej == -1)
          continue;
        unsigned long long liczbaSynow = nodes[i].liczbaSynowDlugosc[d-1];
        nodes[pozycjaPochodnej].liczbaSynowDlugosc[d] += liczbaSynow;
      }
    }
  }

  std::vector<int> pozycjeZNizerowymKorzeniem;
  for (int i = 0; i < nodes.size(); ++i)
  {
    if (nodes[i].korzen > 0)
      pozycjeZNizerowymKorzeniem.push_back(i);
  }

  for (int i = 0; i < granice.size(); ++i)
  {
    unsigned long long granica = granice[i];
    int cyfry[MAX_DLUGOSC];
    for (int d=0; d<MAX_DLUGOSC; ++d)
    {
      cyfry[d] = granica % 10;
      granica = granica / 10;
    }
    granica = granice[i];

    int ostatniaNiezerowa = -1;
    for (int d = 0; d < MAX_DLUGOSC; ++d)
    {
      if (cyfry[d] > 0)
        ostatniaNiezerowa = d;
    }


    unsigned long long results[LICZBA_CYFR];
    for (int c=0; c<LICZBA_CYFR; ++c)
      results[c] = 0;
    for (int d = 0; d < ostatniaNiezerowa; ++d)
    {
      for (int p = 0; p < pozycjeZNizerowymKorzeniem.size(); ++p)
      {
        int pozycja = pozycjeZNizerowymKorzeniem[p];
        results[nodes[pozycja].korzen] += nodes[pozycja].liczbaSynowDlugosc[d+1];
      }
    }
    unsigned long long iloczyn = 1;

    for (int d = ostatniaNiezerowa; d >= 0; --d)
    {
      for (int c = 1; c < cyfry[d]; ++c)
      {
        iloczyn *= c;
        for (int p = 0; p < pozycjeZNizerowymKorzeniem.size(); ++p)
        {
          int pozycja = pozycjeZNizerowymKorzeniem[p];
          if (nodes[pozycja].shortNode.numer % iloczyn != 0)
            continue;
          int pozycjaPrzyjaciela = shortNodesMap[nodes[pozycja].shortNode.numer / iloczyn].pozycja;
          if (d>0)
            results[nodes[pozycja].korzen] += nodes[pozycjaPrzyjaciela].liczbaSynowDlugosc[d];
          else
          {
            if (nodes[pozycjaPrzyjaciela].shortNode.numer == 1)
              results[nodes[pozycja].korzen]++;
          }
        }
        iloczyn /= c;
      }
      iloczyn *= cyfry[d];
      if (cyfry[d] == 0)
        break;
    }
    results[nodes[shortNodesMap[iloczyn].pozycja].korzen] += 1;
    unsigned long long sumaDodatnich = 0;
    for (int c=1; c<LICZBA_CYFR; ++c)
      sumaDodatnich += results[c];
    results[0] = granica - sumaDodatnich;

    for (int c = 0; c < LICZBA_CYFR; ++c)
    {
      std::cout << results[c] << " ";
    }
    std::cout << "\n";
  }

 
  return 0;
}