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: from collections import deque, defaultdict, Counter, OrderedDict
  from math import ceil, sqrt, hypot, factorial, pi, sin, cos, radians
  from heapq import heappush, heappop, heapify, nlargest, nsmallest
  import os
  import sys
  #sys.setrecursionlimit(10**6)
  from itertools import *
  from io import BytesIO, IOBase
  import math
  import bisect
  from math import inf
  import random
  def inp(): return sys.stdin.readline().rstrip("\r\n")  # for fast input
  def out(var): sys.stdout.write(str(var))  # for fast output, always take string
  def lis(): return list(map(int, inp().split()))
  def stringlis(): return list(map(str, inp().split()))
  def sep(): return map(int, inp().split())
  def strsep(): return map(str, inp().split())
  def fsep(): return map(float, inp().split())
  def inpu(): return int(inp())
  M = 1000000007
  
  def main():
      t = 1
      t=int(input())
      for _ in range(1,t+1):
          n, k = map(int, input().split())
          arr = list(map(int, input().split()))
          arr.append(100)
          x = k + 1
          ans = 0
          for i in range(n):
              u = arr[i]
              v = arr[i + 1]
              if x >= 10 ** (v - u):
                  ans += (10 ** u) * (10 ** (v - u) - 1)
                  x -= 10 ** (v - u) - 1
              else:
                  ans += (10 ** u) * x
                  break
          print(ans)
  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)
  input = lambda: sys.stdin.readline().rstrip("\r\n")
  # endregion
  if __name__ == '__main__':
      main()
  