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 Counter
  from sys import *
  from collections import defaultdict as dd
  from math import *
  
  # sys.stdin = open('input.txt', 'r')  
  # sys.stdout = open('output.txt', 'w')
  
  #input functions
  def inp():
      return int(stdin.readline())
  def vinp():
      return map(int,stdin.readline().split())
  def linp():
      return list(map(int,stdin.readline().split()))
  def sinp(n = 1):
      if n==1:
          return stdin.readline()
      elif n==2:
          return list(stdin.readline())
      else:
          return list(stdin.readline().split())
  
  #output function
  def pr(*x, end = "\n"):
      print(*x,end = end)
  
  #others
  def mod(f, val = 1000000007):
      return f % val
  def csort(c):
      sorted(c.items(), key=lambda pair: pair[1], reverse=True)
  def indc(l,n):
      c={}
      for i in range(n):
          c[l[i]]=c.get(l[i],[])+[i+1]
      return c
  
  if __name__ =="__main__":
      cou=inp()
      for _ in range(cou):
          n,k=vinp()
          l = linp()
          k+=1
          f = 0
          for i in range(n):
              if i==n-1:
                  f+=k*(10**(l[n-1]))
              else:
                  x=10**(l[i+1]-l[i])-1
                  f+=(10**(l[i]))*min(x,k)
                  k-=min(x,k)
          pr(f)
          