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: /*
  stream Butter!
  eggyHide eggyVengeance
  I need U
  xiao rerun when
  */
  import static java.lang.Math.*;
  import java.util.*;
  import java.io.*;
  import java.math.*;
  
  public class x1606C
  {
      static long[] pow10;
      public static void main(String hi[]) throws Exception
      {
          pow10 = new long[19];
          pow10[0] = 1L;
          for(int i=1; i < 19; i++)
              pow10[i] = pow10[i-1]*10;
          BufferedReader infile = new BufferedReader(new InputStreamReader(System.in));
          StringTokenizer st = new StringTokenizer(infile.readLine());
          int T = Integer.parseInt(st.nextToken());
          StringBuilder sb = new StringBuilder();
          while(T-->0)
          {
              st = new StringTokenizer(infile.readLine());
              int N = Integer.parseInt(st.nextToken());
              int K = Integer.parseInt(st.nextToken());
              int[] arr = readArr(N, infile, st);
              long current = 0L;
              outer:for(int i=18; i >= 0; i--)
                  for(int d=0; d < 10; d++)
                  {
                      long val = current+d*pow10[i];
                      for(int a=i-1; a >= 0; a--)
                          val += 9*pow10[a];
                      if(calc(val, arr) > K)
                      {
                          current += d*pow10[i];
                          continue outer;
                      }
                  }
              sb.append(current+"\n");
          }
          System.out.print(sb);
      }
      public static long calc(long X, int[] arr)
      {
          long res = 0L;
          for(int i=arr.length-1; i >= 0; i--)
          {
              long val = pow10[arr[i]];
              res += X/val;
              X %= val;
          }
          return res;
      }
      public static int[] readArr(int N, BufferedReader infile, StringTokenizer st) throws Exception
      {
          int[] arr = new int[N];
          st = new StringTokenizer(infile.readLine());
          for(int i=0; i < N; i++)
              arr[i] = Integer.parseInt(st.nextToken());
          return arr;
      }
  }
  /*
  f(s) can be found with easy greedy
  is 99...99 the "highest cost" with d digits? (yes)
  at most 18 digits
   */