description: On the board, Bob wrote n positive integers in [base](https://en.wikipedia.org/wiki/Positional_notation#Base_of_the_numeral_system) 10 with sum s (i. e. in decimal numeral system). Alice sees the board, but accidentally interprets the numbers on the board as base-11 integers and adds them up (in base 11).
  
  What numbers should Bob write on the board, so Alice's sum is as large as possible?
  
  Input
  
  The input consists of multiple test cases. The first line contains an integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.
  
  The only line of each test case contains two integers s and n (1 ≤ s ≤ 10^9; 1 ≤ n ≤ min(100, s)) — the sum and amount of numbers on the board, respectively. Numbers s and n are given in decimal notation (base 10).
  
  Output
  
  For each test case, output n positive integers — the numbers Bob should write on the board, so Alice's sum is as large as possible. If there are multiple answers, print any of them.
  
  Example
  
  Input
  
  
  6
  97 2
  17 1
  111 4
  100 2
  10 9
  999999 3
  
  
  Output
  
  
  70 27 
  17 
  3 4 100 4
  10 90
  1 1 2 1 1 1 1 1 1 
  999900 90 9
  
  Note
  
  In the first test case, 70_{10} + 27_{10} = 97_{10}, and Alice's sum is $$$70_{11} + 27_{11} = 97_{11} = 9 ⋅ 11 + 7 = 106_{10}. (Here x_b represents the number x in base b.) It can be shown that it is impossible for Alice to get a larger sum than 106_{10}$$$.
  
  In the second test case, Bob can only write a single number on the board, so he must write 17.
  
  In the third test case, 3_{10} + 4_{10} + 100_{10} + 4_{10} = 111_{10}, and Alice's sum is $$$3_{11} + 4_{11} + 100_{11} + 4_{11} = 110_{11} = 1 ⋅ 11^2 + 1 ⋅ 11 = 132_{10}. It can be shown that it is impossible for Alice to get a larger sum than 132_{10}$$$.
solution: #!/usr/bin/env python3
  import sys
  import getpass  # not available on codechef
  import math, random
  import functools, itertools, collections, heapq, bisect
  from collections import Counter, defaultdict, deque
  input = sys.stdin.readline  # to read input quickly
  
  # available on Google, AtCoder Python3, not available on Codeforces
  # import numpy as np
  # import scipy
  
  M9 = 10**9 + 7  # 998244353
  yes, no = "YES", "NO"
  # d4 = [(1,0),(0,1),(-1,0),(0,-1)]
  # d8 = [(1,0),(1,1),(0,1),(-1,1),(-1,0),(-1,-1),(0,-1),(1,-1)]
  # d6 = [(2,0),(1,1),(-1,1),(-2,0),(-1,-1),(1,-1)]  # hexagonal layout
  MAXINT = sys.maxsize
  
  # if testing locally, print to terminal with a different color
  OFFLINE_TEST = getpass.getuser() == "hkmac"
  # OFFLINE_TEST = False  # codechef does not allow getpass
  def log(*args):
      if OFFLINE_TEST:
          print('\033[36m', *args, '\033[0m', file=sys.stderr)
  
  def solve(*args):
      # screen input
      if OFFLINE_TEST:
          log("----- solving ------")
          log(*args)
          log("----- ------- ------")
      return solve_(*args)
  
  def read_matrix(rows):
      return [list(map(int,input().split())) for _ in range(rows)]
  
  def read_strings(rows):
      return [input().strip() for _ in range(rows)]
  
  def minus_one(arr):
      return [x-1 for x in arr]
  
  def minus_one_matrix(mrr):
      return [[x-1 for x in row] for row in mrr]
  
  # ---------------------------- template ends here ----------------------------
  
  
  def solve_(n, s):
      # your solution here
  
      res = [1 for _ in range(s)]
      n -= s
  
      for i in range(10,0,-1):
          if n == 0:
              break
          demonination = 10**i
          res.sort(key=lambda x: x%demonination)
          res.reverse()
          for i,x in enumerate(res):
              next_target = demonination - x%demonination
              if n >= next_target:
                  res[i] += next_target
                  n -= next_target
          while n >= demonination:
              for i,x in enumerate(res):
                  next_target = demonination - x%demonination
                  if n >= next_target:
                      res[i] += next_target
                      n -= next_target
  
      res[0] += n
  
      cnt = 0
      for x in res:
          cnt += int(str(x),11)
      log(cnt)
  
      return res
  
  
  # for case_num in [0]:  # no loop over test case
  # for case_num in range(100):  # if the number of test cases is specified
  for case_num in range(int(input())):
  
      # read line as an integer
      # k = int(input())
  
      # read line as a string
      # srr = input().strip()
  
      # read one line and parse each word as a string
      # lst = input().split()
  
      # read one line and parse each word as an integer
      n,s = list(map(int,input().split()))
      # lst = list(map(int,input().split()))
      # lst = minus_one(lst)
  
      # read multiple rows
      # arr = read_strings(k)  # and return as a list of str
      # mrr = read_matrix(k)  # and return as a list of list of int
      # mrr = minus_one_matrix(mrr)
  
      res = solve(n,s)  # include input here
  
      # print length if applicable
      # print(len(res))
  
      # parse result
      res = " ".join(str(x) for x in res)
      # res = "\n".join(str(x) for x in res)
      # res = "\n".join(" ".join(str(x) for x in row) for row in res)
  
      # print result
      # print("Case #{}: {}".format(case_num+1, res))   # Google and Facebook - case number required
  
      print(res)