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 java.util.*;
  import java.io.*;
  
   //import static com.sun.tools.javac.jvm.ByteCodes.swap;
  
  
  public class fastTemp {
  
  
  
          static FastScanner fs = null;
          public static void main(String[] args) {
              fs = new FastScanner();
              PrintWriter out = new PrintWriter(System.out);
              int t = fs.nextInt();
              while (t-->0) {
  
                  //  WRITE BELOW
  
          int n = fs.nextInt();
          int k = fs.nextInt();
  
  
                  int[] arr = new int[n];
                  HashSet<Integer> h = new HashSet<>();
                  for(int i=0;i<n;i++){
                      arr[i]= fs.nextInt();
  
                    }
    int nu = 0;
          int i = 0;
          int j = 1;
          int z = 1;
          long sum = 0L;
          for( i = 0;i<n-1;i++){
              int y = arr[i+1]-arr[i];
              long x =(long)Math.pow(10,y)-1;
              if(x>k){
                  sum += (k+1)*(long)Math.pow(10,arr[i]);
                  k=-2;
                  break;
  
              }else{
                  sum += x*(long)Math.pow(10,arr[i]);
                  k = k-(int)x;
              }
          }
          if(k>=0){
              sum += (k+1)*(long)Math.pow(10,arr[i]);
          }
             out.println(sum);
          }
  
              out.println();
              out.close();
          }
          static void sort(int[] a) {
              ArrayList<Integer> l=new ArrayList<>();
              for (int i:a) l.add(i);
              Collections.sort(l);
              for (int i=0; i<a.length; i++) a[i]=l.get(i);
          }
          static class FastScanner {
              BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
              StringTokenizer st = new StringTokenizer("");
  
              String next() {
                  while (!st.hasMoreTokens())
                      try {
                          st = new StringTokenizer(br.readLine());
                      } catch (IOException e) {
                          e.printStackTrace();
                      }
                  return st.nextToken();
              }
  
              int nextInt() {
                  return Integer.parseInt(next());
              }
  
              int[] readArray(int n) {
                  int[] a = new int[n];
                  for (int i = 0; i < n; i++) a[i] = nextInt();
                  return a;
              }
  
              long nextLong() {
                  return Long.parseLong(next());
              }
          }
              // ------------------------------------------swap----------------------------------------------------------------------
  
              static void swap(int arr[],int i,int j)
              {
                  int temp=arr[i];
                  arr[i]=arr[j];
                  arr[j]=temp;
              }
  
  
              //-------------------------------------------seiveOfEratosthenes----------------------------------------------------
  
  
              static boolean prime[];
              static void sieveOfEratosthenes(int n)
              {
                  // Create a boolean array
                  // "prime[0..n]" and
                  // initialize all entries
                  // it as true. A value in
                  // prime[i] will finally be
                  // false if i is Not a
                  // prime, else true.
                  prime= new boolean[n + 1];
                  for (int i = 0; i <= n; i++)
                      prime[i] = true;
  
                  for (int p = 2; p * p <= n; p++)
                  {
                      // If prime[p] is not changed, then it is a
                      // prime
                      if (prime[p] == true)
                      {
                          // Update all multiples of p
                          for (int i = p * p; i <= n; i += p)
                              prime[i] = false;
                      }
                  }
  
                  // Print all prime numbers
  //        for (int i = 2; i <= n; i++)
  //        {
  //            if (prime[i] == true)
  //                System.out.print(i + " ");
  //        }
              }
  
  
  
              // ---------------------------------------- power------------------------------------------------------------------
  
  
  
              public static long power(int a , int b) {
                  if (b == 0) {
                      return 1;
                  } else if (b == 1) {
                      return a;
  
                  } else {
  
                      long R = power(a, b / 2);
                      if (b % 2 != 0) {
  
  
                          return (((power(a, b / 2))) * a * ((power(a, b / 2))));
                      } else {
                          return ((power(a, b / 2))) * ((power(a, b / 2)));
                      }
                  }
  
              }
  
  
  
              //--------------------------------------lower bound----------------------------------------------------------
  
  
              static int LowerBound(int a[], int x)
              { // x is the target value or key
                  int l=-1,r=a.length;
                  while(l+1<r) {
                      int m=(l+r)>>>1;
                      if(a[m]>=x) r=m;
                      else l=m;
                  }
                  return r;
              }
  
              //--------------------------------------------------------------------------------------------------------------
              public static int log2(int x) {
                  return (int) (Math.log(x) / Math.log(2));
              }
  
  //---------------------------------------EXTENDED EUCLID ALGO--------------------------------------------------------
      public static class Pair{
          int x;
          int y;
          public Pair(int x,int y){
              this.x = x;
              this.y = y ;
          }
      }
  
      public static Pair Euclid(int a,int b){
  
          if(b==0){
              return new Pair(1,0);  // answer of x and y
          }
  
          Pair dash = Euclid(b,a%b);
  
          return new Pair(dash.y , dash.x - (a/b)*dash.y);
  
  
      }
  //--------------------------------GCD------------------GCD-----------GCD--------------------------------------------
  
      public static long gcd(long a,long b){
                  if(b==0){
                      return a;
                  }
  
                  return gcd(b,a%b);
      }
  }
  
  
  
  
  