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.io.*;
  import java.util.*;
  
  public class Main {
      public int isNegativeWeightCycle(int n, int[][] edges)
      {
          //code here
          int dis[]=new int[n];
          Arrays.fill(dis,Integer.MAX_VALUE);
          for (int i=1;i<n;i++){
              for (int j=0;j<edges.length;j++){
                  if (dis[edges[j][0]]+edges[j][2]<dis[edges[j][1]]){
                      dis[edges[j][1]]=dis[edges[j][0]]+edges[j][2];
                  }
              }
          }
          for (int i=0;i<edges.length;i++){
              if (dis[edges[i][0]]+edges[i][2]<dis[edges[i][1]]){
                  return 1;
              }
          }
          return 0;
  
      }
      static int[] bellman_ford(int V, ArrayList<ArrayList<Integer>> adj, int S)
      {
          // Write your code here
          int dis[]= new int[V];
          Arrays.fill(dis,Integer.MAX_VALUE);
          dis[S]=0;
          for (int i=1;i<V;i++){
              for (int j=0;j<adj.size();j++){
                  if (adj.get(j).get(0)+adj.get(j).get(2)<adj.get(j).get(1)){
                      adj.get(j).add(adj.get(j).get(0)+adj.get(j).get(2));
                  }
              }
          }
          return dis;
  
      }
      public static void main(String[] args) {
          FastScanner sc = new FastScanner();
  //        Scanner sc = new Scanner(System.in);
          int t=sc.nextInt();
          outer:while (t-->=1){
  
              int x=sc.nextInt();
              long y=sc.nextLong();
              y++;
              long sol=0;
              int a[]=sc.readArray(x);
              for (int i=0;i<x-1;i++){
                  if (y>0){
                      long z=(long) Math.pow(10,a[i+1]-a[i])-1;
                      long val=Math.min(z,y);
                      sol=sol+(long) (Math.pow(10,a[i])*val);
                      y=y-val;
                  }
              }
              sol=sol+(long) (y*Math.pow(10,a[x-1]));
              System.out.println(sol);
  
  
  
          }
  
  
  
  
      }
  
  
  
  
  
  //            out.flush();
  
  
  
      //------------------------------------if-------------------------------------------------------------------------------------------------------------------------------------------------
      //sieve
      static void primeSieve(int a[]){
          //mark all odd number as prime
          for (int i=3;i<a.length;i+=2){
              a[i]=1;
          }
          for (long i=3;i<a.length;i+=2){
              //if the number is marked then it is prime
              if (a[(int) i]==1){
                  //mark all muliple of the number as not prime
                  for (long j=i*i;j<a.length;j+=i){
                      a[(int)j]=0;
  
                  }
              }
          }
          a[2]=1;
          a[1]=a[0]=0;
      }
      //prime
      static boolean isPrime(long n){
          if (n==2)return true;
          if (n==1)return false;
          for (long i=2;i*i<=n;i++){
              if (n%i==0)return false;
          }
          return true;
      }
  
      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 String sortString(String s) {
          char temp[] = s.toCharArray();
          Arrays.sort(temp);
          return new String(temp);
      }
      static class Pair implements Comparable<Pair> {
          int a;
          int b;
  
  
          public Pair(int a, int b) {
              this.a = a;
              this.b = b;
  
          }
          public int compareTo(Pair o) {
              return a == o.a ? b - o.b : a - o.a;
          }
          //        to sort first part
  //        public int compareTo(Pair other) {
  //            if (this.a == other.a) return other.b >=this.b ? -1 : 1;
  //            else if (this.a < other.a) return 1;
  //            else return -1;
  //        }
  //        public int compareTo(Pair other) {
  //            if (this.b == other.b){
  //                if (this.a> other.a)return 1;
  //                else return -1;
  //            }
  //            if (this.b > other.b) return 1;
  //            else return -1;
  //        }
          //sort on the basis of first part only
  //        public int compareTo(Pair other) {
  //            if (this.a == other.a) return 0;
  //             if (this.a > other.a) return 1;
  //            else return -1;
  //        }
  
      }
      static int[] frequency(String s){
          int fre[]= new int[26];
          for (int i=0;i<s.length();i++){
              fre[s.charAt(i)-'a']++;
          }
          return fre;
      }
      static long LOWERBOUND(long a[],long k){
          int s=0,e=a.length-1;
          long ans=-1;
          while (s<=e){
              int mid=(s+e)/2;
              if (a[mid]<=k){
                  ans=mid;
                  s=mid+1;
              }
              else {
                  e=mid-1;
              }
          }
          return ans;
      }
      static long mod =(long)(1e9+7);
      static long mod(long x) {
          return ((x % mod + mod) % mod);
      }
      static long div(long a,long b){
          return ((a/b)%mod+mod)%mod;
      }
      static long add(long x, long y) {
          return mod(mod(x) + mod(y));
      }
      static long mul(long x, long y) {
          return mod(mod(x) * mod(y));
      }
      //Fast Power(logN)
      static int fastPower(long a,long n){
          int ans=1;
          while (n>0){
              long lastBit=n&1;
              if (lastBit==1){
                  ans=(int)mul(ans,a);
              }
  
              a=(int)mul(a,a);
              n>>=1;
          }
          return ans;
      }
      static int[] find(int n, int start, int diff) {
          int a[] = new int[n];
          a[0] = start;
          for (int i = 1; i < n; i++) a[i] = a[i - 1] + diff;
          return a;
      }
      static void swap(int a, int b) {
          int c = a;
          a = b;
          b = c;
      }
      static void printArray(int a[]) {
          for (int i = 0; i < a.length; i++) {
              System.out.print(a[i] + " ");
          }
      }
      static boolean sorted(int a[]) {
          int n = a.length;
          boolean flag = true;
          for (int i = 0; i < n - 1; i++) {
              if (a[i] > a[i + 1]) flag = false;
          }
          if (flag) return true;
          else return false;
      }
      public static int findlog(long n) {
          if (n == 0)
              return 0;
  
          if (n == 1)
              return 0;
          if (n == 2)
              return 1;
          double num = Math.log(n);
          double den = Math.log(2);
          if (den == 0)
              return 0;
          return (int) (num / den);
      }
      public static long gcd(long a, long b) {
          if (b % a == 0)
              return a;
          return gcd(b % a, a);
      }
      public static int gcdInt(int a, int b) {
  
          if (b % a == 0)
              return a;
  
          return gcdInt(b % a, a);
  
      }
      static void sortReverse(int[] a) {
          ArrayList<Integer> l = new ArrayList<>();
          for (int i : a) l.add(i);
          //        Collections.sort.(l);
          Collections.sort(l, Collections.reverseOrder());
          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());
          }
          double nextDouble(){
              return Double.parseDouble(next());
          }
  
          int[] readArray(int n) {
              int[] a = new int[n];
              for (int i = 0; i < n; i++) a[i] = nextInt();
              return a;
          }
  
          long[] readArrayLong(long n) {
              long[] a = new long[(int) n];
              for (int i = 0; i < n; i++) a[i] = nextLong();
              return a;
          }
          double[] readArrayDouble(long n) {
              double[] a = new double[(int) n];
              for (int i = 0; i < n; i++) a[i] = nextDouble();
              return a;
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
      }
  }