#include <algorithm>
#include <cstdio>
#include <vector>

class Number {
public:
  explicit Number(long long x) {
    if (x == 0) {
      exp_2 = exp_3 = exp_5 = exp_7 = -1;
      return;
    }
    auto helper = [](int p, int& exp, long long &x) {
      exp = 0;
      while (x % p == 0) {
        x /= p;
        ++exp;
      }    
    };
    helper(2, exp_2, x);
    helper(3, exp_3, x);
    helper(5, exp_5, x);
    helper(7, exp_7, x);
  }

  Number(int exp_2_, int exp_3_, int exp_5_, int exp_7_) {
    exp_2 = exp_2_;
    exp_3 = exp_3_;
    exp_5 = exp_5_;
    exp_7 = exp_7_;
  }

  Number(const Number& number) = default;

  bool CanDivide(Number x) {
    return x.exp_2 <= exp_2 &&
           x.exp_3 <= exp_3 &&
           x.exp_5 <= exp_5 &&
           x.exp_7 <= exp_7;
  }

  Number Divide(Number x) {
    return Number(exp_2 - x.exp_2, exp_3 - x.exp_3, exp_5 - x.exp_5, exp_7 - x.exp_7);
  }

  int exp_2;
  int exp_3;
  int exp_5;
  int exp_7;
};

class DigitizedNumber {
public:
  explicit DigitizedNumber(long long x) {
    // printf("konstruuje z %lld\n", x);
    if (x == 0) {
      digit.push_back(0);
      return;
    }
    while (x > 0) {
      // printf("x = %lld\n", x);
      digit.push_back(x % 10);
      // printf("pushing back %d\n", (int) (x) % 10);
      x /= 10;
    }
    std::reverse(digit.begin(), digit.end());
  }
  std::vector<int> digit;
};

long long preC[21][21];

void PrecalculateC() {
  preC[0][0] = 1;
  preC[1][0] = 1;
  preC[1][1] = 1;
  for (int n = 2; n <= 20; ++n) {
    for (int k = 0; k <= n; ++k) {
      preC[n][k] = preC[n-1][k-1] + preC[n-1][k];
    }
  }
}

// n <= 20
long long C(int n, int k) {
  return preC[n][k];
}

long long preD[21][61][39];

void PrecalculateD() {
  preD[0][0][0] = 1;
  for (int i = 1; i <= 20; ++i) {
    //printf("i = %d\n", i);
    for (int twos_ = 0; twos_ <= 60; ++twos_) {
      for (int threes = 0; threes <= 38; ++threes) {
        for (int eights = 0; eights <= twos_ / 3; ++eights) {
          int twos = twos_ - 3*eights;
          int new_i = i - eights;

          // Musimy zrobic liczbe skladajaca sie z new_i cyfr, a mamy do dyspozycji twos dwojek oraz threes trojek.
          // Nie wolno juz robic osemek.

          if (new_i < 0) {
            break;
          }

          if (new_i > twos + threes) {
            continue;
          }

          for (int fours = 0; fours <= twos / 2; ++fours) {
            for (int nines = 0; nines <= threes / 2; ++nines) {
              int j = new_i - fours - nines;
              int new_twos = twos - 2*fours;
              int new_threes = threes - 2*nines;
              if (j < 0) {
                break;
              }
              if (j > new_twos + new_threes) {
                continue;
              }
              // Doliczamy szostki.
              int sixes = new_twos + new_threes - j;
              if (sixes > new_twos || sixes > new_threes) {
                continue;
              }
              new_twos -= sixes;
              new_threes -= sixes;

              // printf("preD[%d][%d][%d] <- %d %d %d %d %d %d\n", i, twos_, threes, new_twos, new_threes, fours, sixes, eights, nines);

              // Liczymy calosc.
              preD[i][twos_][threes] +=
                C(i, eights) *
                C(i - eights, nines) *
                C(i - eights - nines, sixes) *
                C(i - eights - nines - sixes, fours) *
                C(i - eights - nines - sixes - fours, new_twos) *
                C(i - eights - nines - sixes - fours - new_twos, new_threes);
            }
          }
        }
      }
    }
  }
}

long long D(int length, int twos, int threes) {
  if (length < 0 || length > 20) return 0;
  if (twos < 0 || twos > 61) return 0;
  if (threes < 0 || threes > 39) return 0;

  return preD[length][twos][threes];
}

constexpr long long MX = 1000000000000000001;
std::vector<Number> special_number;
std::vector<long long> special_n;
std::vector<int> result_for_special;

long long Multiply(long long n) {
  long long result = 1;
  if (n == 0) {
      return 0;
  }
  while (n > 0) {
      result *= n%10;
      n /= 10;
  }
  return result;
}

int Algo(long long n) {
  while (n >= 10) {
      n = Multiply(n);
  }
  return (int) n;
}

long long Power(int a, int n) {
  long long result = 1;
  for (int i = 0; i < n; ++i) {
      result *= a;
  }
  return result;
}

void PrecalculateSpecial() {
  for (int w2 = 0; w2 < 60; ++w2) {
    for (int w3 = 0; w3 < 38; ++w3) {
        if (Power(2, w2) * Power(3, w3) > MX) {
          break;
        }
        for (int w5 = 0; w5 < 26; ++w5) {
          if (Power(2, w2) * Power(3, w3) * Power(5, w5) > MX) {
            break;
          }
          for (int w7 = 0; w7 < 22; ++w7) {
            if (Power(2, w2) * Power(3, w3) * Power(5, w5) * Power(7, w7) > MX) {
              break;
            }
            long long x = Power(2, w2) * Power(3, w3) * Power(5, w5) * Power(7, w7);
            special_number.emplace_back(w2, w3, w5, w7);
            special_n.push_back(x);
            result_for_special.push_back(Algo(x));
          }
        }
    }
  }
  //("mam specjalnych: %zu\n", special_n.size());
}

long long Count3(int length, Number x) {
  //("    count3(%d, %d %d %d %d)\n", length, x.exp_2, x.exp_3, x.exp_5, x.exp_7);
  long long c = C(length, x.exp_5) * C(length - x.exp_5, x.exp_7);
  length -= x.exp_5 + x.exp_7;
  if (length < 0) {
    return 0;
  }

  if (length > x.exp_2 + x.exp_3) {
    return 0;
  }

  return D(length, x.exp_2, x.exp_3) * c;
}

long long Count2(int length, Number x) {
  //("  count2(%d, %d %d %d %d)\n", length, x.exp_2, x.exp_3, x.exp_5, x.exp_7);
  long long result = 0;
  for (int ones = 0; ones <= length; ++ones) {
    //printf("  ones = %d\n", ones);
    long long partial_result = Count3(length - ones, x);
    //printf("  partial_result = %lld\n", partial_result);
    result += C(length, ones) * partial_result;
  }
  return result;
}

long long Count(DigitizedNumber n, Number x) {
  long long result = 0;
  for (int len = 1; len < n.digit.size(); ++len) {
    long long partial_result = Count2(len, x);
    //printf("len = %d partial_result = %lld\n", len, partial_result);
    result += partial_result;
  }
  //printf("size of digits %zu\n", n.digit.size());
  for (int i = 0; i < n.digit.size(); ++i) {
    //printf("digit[%d] = %d\n", i, n.digit[i]);
    for (int set_digit = 1; set_digit < n.digit[i]; ++set_digit) {
      //printf("Ustawiam cyfre na %d\n", set_digit);
      Number d{set_digit};
      if (x.CanDivide(d)) {
        //printf("Moge dzielic, ide dalej.");
        result += Count2(n.digit.size() - i - 1, x.Divide(d));
      }
    }
    Number d{n.digit[i]};
    if (!x.CanDivide(d)) {
      break;
    }
    x = x.Divide(d);
  }
  return result;
}

void Solve() {
  long long n;
  scanf("%lld", &n);
  std::vector<long long> result(10, 0);
  for (size_t idx = 0; idx < special_n.size(); ++idx) {
    if (special_n[idx] > n) {
      continue;
    }
    if (special_n[idx] > 10) {
      //--result[result_for_special[idx]];
    }
    //printf("----------------------------licze dla %lld\n", special_n[idx]);
    const auto partial_sum = Count(DigitizedNumber{n}, special_number[idx]);
    result[result_for_special[idx]] += partial_sum;
    //printf("result[%d] += %lld\n", result_for_special[idx], partial_sum);
  }
  result[Algo(n)]++;
  result[0] = n;
  for (int i = 1; i <= 9; ++i) result[0] -= result[i];
  for (const auto& r : result) printf("%lld ", r);
  printf("\n");
}

int main() {
  PrecalculateC();
  PrecalculateD();
  PrecalculateSpecial();
  int t;
  scanf("%d", &t);

  for (int tc = 0; tc < t; ++tc) {
    Solve();
  }
}