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: //jai Shree Krishna
  import java.io.BufferedReader;
  import java.io.BufferedWriter;
  import java.io.IOException;
  import java.util.Collections;
  import java.io.InputStreamReader;
  import java.io.PrintWriter;
  import java.io.OutputStreamWriter;
  import java.util.ArrayList;
  import java.util.StringTokenizer;
  public class C{
  // author: Tarun Verma
  	static FastScanner sc = new FastScanner();
  	static int inf = Integer.MAX_VALUE;
  	static long mod = 1000000007;
  	static BufferedWriter output = new BufferedWriter(
  			new OutputStreamWriter(System.out));
  	static PrintWriter out=new PrintWriter(System.out);
  	/* Common Mistakes By Me
  	 * make sure to read the bottom part of question
  	 * special cases (n=1?)
  	 * In Game Theory Check your solution and consider all the solutions
  	 * Always initialise value to the declare array in local scope
  	 * don't use debugs in interactive problems
  	 * Always Reset vis,adj array upto n+1 otherwise can cause TLE
  	 */
  	public static void solve() {
  		long n = sc.nextLong();
  		long k = sc.nextLong();
  		long arr[] = sc.readLongArray((int) n);
  		int i =0;
  		k++;
  		long sum = 0;
  		while(k != 0 && i < n) {
  			if(i == n-1) {
  				sum += (long)Math.pow(10, arr[i]) * k;
  				k = 0;
  				continue;
  			}
  			long req = (long)Math.pow(10, arr[i+1]) - sum - 1;
  			long tmp1 = req / (long)Math.pow(10, arr[i]);
  			
  			long tmp = min(tmp1, k);
  //			System.out.println("tmp1: "  + tmp1);
  			sum += (tmp * Math.pow(10, arr[i]));
  			k-= tmp;
  			i++;
  			
  		}
  		System.out.println(sum);
  	}
  	public static void main(String[] args) {
  		int t = 1;
  		t = sc.nextInt();
  		outer: for (int tt = 0; tt < t; tt++) {
  			solve();
  		}
  	}
  	
  ////////////////////////////////////////////////////////////////////////////////////
  ////////////////////DO NOT BELOW THIS LINE //////////////////////////////////
  ////////////////////////////////////////////////////////////////////////////////////
  	
  	static int max(int a, int b) { return Math.max(a, b);} 
  	static int min(int a, int b) {return Math.min(a, b);}
  	static long max(long a, long b){return Math.max(a, b);}
  	static long min(long a, long b) {return Math.min(a, b);}
  	static void sort(int arr[]) {
  		ArrayList<Integer> a = new ArrayList<Integer>();
  		for(int i: arr) a.add(i);
  		Collections.sort(a);
  		for(int i=0;i<arr.length;i++) arr[i] = a.get(i);
  	}
  	static void sort(long arr[]) {
  		ArrayList<Long> a = new ArrayList<Long>();
  		for(long i: arr) a.add(i);
  		Collections.sort(a);
  		for(int i=0;i<arr.length;i++) arr[i] = a.get(i);
  	}
  	static int abs(int a) {return Math.abs(a);}
  	static long abs(long a) {return Math.abs(a);}
  	static int gcd(int a, int b) {
  		if (b == 0)
  			return a;
  		return gcd(b, a % b);
  	}
  	static long gcd(long a, long b) {
  		if (b == 0)
  			return a;
  		return gcd(b, a % b);
  	}
  	
  	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[] readLongArray(int n) {
  			long[] a = new long[n];
  			for (int i = 0; i < n; i++)
  				a[i] = nextLong();
  			return a;
  		}
  		
  		int[][] read2dArray(int n, int m) {
  			int arr[][] = new int[n][m];
  			for (int i = 0; i < n; i++) {
  				for (int j = 0; j < m; j++) {
  					arr[i][j] = nextInt();
  				}
  			}
  			return arr;
  		}
  		
  		ArrayList<Integer> readArrayList(int n) {
  			ArrayList<Integer> arr = new ArrayList<Integer>();
  			for (int i = 0; i < n; i++) {
  				int a = nextInt();
  				arr.add(a);
  			}
  			return arr;
  		}
  		
  		long nextLong() {
  			return Long.parseLong(next());
  		}
  	}
  	
  	static class pair {
  		int fr, sc;
  		
  		pair(int fr, int sc) {
  			this.fr = fr;
  			this.sc = sc;
  		}
  	}
  	
  ////////////////////////////////////////////////////////////////////////////////////	
  	
  }
  