description: In Berland, n different types of banknotes are used. Banknotes of the i-th type have denomination 10^{a_i} burles (burles are the currency used in Berland); the denomination of banknotes of the first type is exactly 1.
  
  Let's denote f(s) as the minimum number of banknotes required to represent exactly s burles. For example, if the denominations of banknotes used in Berland are 1, 10 and 100, then f(59) = 14: 9 banknotes with denomination of 1 burle and 5 banknotes with denomination of 10 burles can be used to represent exactly 9 ⋅ 1 + 5 ⋅ 10 = 59 burles, and there's no way to do it with fewer banknotes.
  
  For a given integer k, find the minimum positive number of burles s that cannot be represented with k or fewer banknotes (that is, f(s) > k).
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 10^4) — number of test cases.
  
  The first line of each test case contains two integers n and k (1 ≤ n ≤ 10; 1 ≤ k ≤ 10^9).
  
  The next line contains n integers a_1, a_2, ..., a_n (0 = a_1 < a_2 < ... < a_n ≤ 9).
  
  Output
  
  For each test case, print one integer — the minimum positive number of burles s that cannot be represented with k or fewer banknotes.
  
  Example
  
  Input
  
  
  4
  3 13
  0 1 2
  2 777
  0 4
  3 255
  0 1 3
  10 1000000000
  0 1 2 3 4 5 6 7 8 9
  
  
  Output
  
  
  59
  778
  148999
  999999920999999999
solution: import os
  import sys
  from io import BytesIO, IOBase
  from collections import Counter
  import math as mt
  
  BUFSIZE = 8192
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = "x" in file.mode or "r" not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b"\n") + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode("ascii"))
          self.read = lambda: self.buffer.read().decode("ascii")
          self.readline = lambda: self.buffer.readline().decode("ascii")
  
  
  sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
  
  
  def gcd(a, b):
      if a == 0:
          return b
      return gcd(b % a, a)
  
  
  def lcm(a, b):
      return (a * b) / gcd(a, b)
  
  
  mod = int(1e9) + 7
  
  
  def power(k, n):
      if n == 0:
          return 1
      if n % 2:
          return (power(k, n - 1) * k) % mod
      t = power(k, n // 2)
      return (t * t) % mod
  
  
  def totalPrimeFactors(n):
      count = 0
      if (n % 2) == 0:
          count += 1
          while (n % 2) == 0:
              n //= 2
  
      i = 3
      while i * i <= n:
          if (n % i) == 0:
              count += 1
              while (n % i) == 0:
                  n //= i
          i += 2
      if n > 2:
          count += 1
      return count
  
  
  # #MAXN = int(1e7 + 1)
  # # spf = [0 for i in range(MAXN)]
  #
  #
  # def sieve():
  #     spf[1] = 1
  #     for i in range(2, MAXN):
  #         spf[i] = i
  #     for i in range(4, MAXN, 2):
  #         spf[i] = 2
  #
  #     for i in range(3, mt.ceil(mt.sqrt(MAXN))):
  #         if (spf[i] == i):
  #             for j in range(i * i, MAXN, i):
  #                 if (spf[j] == j):
  #                     spf[j] = i
  #
  #
  # def getFactorization(x):
  #     ret = 0
  #     while (x != 1):
  #         k = spf[x]
  #         ret += 1
  #         # ret.add(spf[x])
  #         while x % k == 0:
  #             x //= k
  #
  #     return ret
  
  
  # Driver code
  
  # precalculating Smallest Prime Factor
  # sieve()
  
  def main():
      for _ in range(int(input())):
          # n=int(input())
          n, k = map(int, input().split())
          k += 1
          a = list(map(int, input().split()))
          for i in range(n):
              a[i] = 10 ** a[i]
          ans = 0
          m = [1]
          z = '9'
          for i in range(15):
              m.append(int(z))
              z += '9'
          for i in range(1, n):
              if k * a[i - 1] < a[i]:
                  ans += k * (a[i - 1])
                  k = 0
                  break
              for j in range(len(m)):
                  if m[j] * a[i - 1] > a[i] or k < m[j]:
                      ans += m[j - 1] * a[i - 1]
                      k -= m[j - 1]
                      break
              # print(t)
          ans += (k * (a[-1]))
          print(ans)
  
      return
  
  
  if __name__ == "__main__":
      main()
  