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: /* package codechef; // don't place package name! */
  
  import java.util.*;
  import java.lang.*;
  import java.io.*;
  /* Name of the class has to be "Main" only if the class is public. */
  public class Codechef
  {static class FastReader 
      { 
          BufferedReader br; 
          StringTokenizer st; 
    
          public FastReader() 
          { 
              br = new BufferedReader(new
                       InputStreamReader(System.in)); 
          } 
    
          String next() 
          { 
              while (st == null || !st.hasMoreElements()) 
              { 
                  try
                  { 
                      st = new StringTokenizer(br.readLine()); 
                  } 
                  catch (IOException  e) 
                  { 
                      e.printStackTrace(); 
                  } 
              } 
              return st.nextToken(); 
          } 
    
          int nextInt() 
          { 
              return Integer.parseInt(next()); 
          } 
    
          long nextLong() 
          { 
              return Long.parseLong(next()); 
          } 
    
          double nextDouble() 
          { 
              return Double.parseDouble(next()); 
          } 
    
          String nextLine() 
          { 
              String str = ""; 
              try
              { 
                  str = br.readLine(); 
              } 
              catch (IOException e) 
              { 
                  e.printStackTrace(); 
              } 
              return str; 
          } 
      } 
  //    static int mod = 998244353 ;
  //    static int N = 200005;
  //    static long factorial_num_inv[] = new long[N+1];
  //    static long natual_num_inv[] = new long[N+1];
  //    static long fact[] = new long[N+1];
  //    static void InverseofNumber() 
  //{ 
  //    natual_num_inv[0] = 1;
  //    natual_num_inv[1] = 1; 
  //    for (int i = 2; i <= N; i++) 
  //        natual_num_inv[i] = natual_num_inv[mod % i] * (mod - mod / i) % mod; 
  //} 
  //static void InverseofFactorial() 
  //{ 
  //    factorial_num_inv[0] = factorial_num_inv[1] = 1; 
    
  //    for (int i = 2; i <= N; i++) 
  //        factorial_num_inv[i] = (natual_num_inv[i] * factorial_num_inv[i - 1]) % mod; 
  //} 
  //static long nCrModP(long N, long R) 
  //{ 
  //    long ans = ((fact[(int)N] * factorial_num_inv[(int)R]) % mod * factorial_num_inv[(int)(N - R)]) % mod; 
  //    return ans%mod; 
  //}
      //static boolean prime[];
      //static void sieveOfEratosthenes(int n)
      //{
      //    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;
      //        }
      //    }
   
          
      //}
      
  	public static void main (String[] args) throws java.lang.Exception
  	{
      //    InverseofNumber();
      //    InverseofFactorial();
      //   fact[0] = 1; 
      //   for (long i = 1; i <= 2*100000; i++)
      //   { 
      //       fact[(int)i] = (fact[(int)i - 1] * i) % mod; 
      //   }
      
  		FastReader scan = new FastReader();
  		PrintWriter pw = new PrintWriter(System.out);
          int t = scan.nextInt();
          while(t-->0){
              int n = scan.nextInt();
              long k = scan.nextLong();
              long a[] = new long[n];
              for(int i=0;i<n;i++){
                  a[i]  = scan.nextLong();
                  a[i] = bin_exp_mod(10,a[i]);
              }
              long sum = 0;
              int i = 1;
              if(n==1)
              pw.println(k+1);
              else{
              for(i=1;i<n;i++){
                  long x = a[i]/a[i-1]-1;
                  
                  if(k>=x){
                      sum = sum+x*a[i-1];
                      
                  }
                  else{
                      sum = sum+k*a[i-1];
                      if(i==1)
                      sum = sum+1;
                      break;
                  }
                  if(i==1)
                  k = k-x+1;
                  else
                  k = k-x;
              }
              if(i==n){
                  sum = sum+k*a[i-1];
              }
              pw.println(sum);}
              pw.flush();
          }
      }
      static long bin_exp_mod(long a,long n){
  	   
  	    long res = 1;
  	   
  	    if(a==0)
  	    return 0;
  	    while(n!=0){
  	        if(n%2==1){
  	            res = ((res)*(a));
  	        }
  	           n = n/2;
  	            a = ((a)*(a));
  	    }
  	   
  	    return res;
  	}
  //   static long gcd(long a,long b){
  //       if(a==0)
  //       return b;
  //       return gcd(b%a,a);
  //   }
  //   static long lcm(long a,long b){
  //       return (a/gcd(a,b))*b;
  //   }
  }
  //class Pair{
  //    Integer x,y;
  //    Pair(int x,int y){
  //        this.x = x;
  //        this.y = y;
  //    }
  //    public boolean equals(Object obj) {
  //        // TODO Auto-generated method stub
  //        if(obj instanceof Pair)
  //        {
  //            Pair temp = (Pair) obj;
  //            if(this.x.equals(temp.x) && this.y.equals(temp.y))
  //                return true;
  //        }
  //        return false;
  //    }
  
  //    @Override
  //    public int hashCode() {
  //        // TODO Auto-generated method stub
          
  //        return (this.x.hashCode() + this.y.hashCode());        
  //    }
  //}
  //class Compar implements Comparator<Pair>{
  //    public int compare(Pair p1,Pair p2){
  //        return p1.x-p2.x;
  //    }
  //}
  