description: You are given an integer k and a string s that consists only of characters 'a' (a lowercase Latin letter) and '*' (an asterisk).
  
  Each asterisk should be replaced with several (from 0 to k inclusive) lowercase Latin letters 'b'. Different asterisk can be replaced with different counts of letter 'b'.
  
  The result of the replacement is called a BA-string.
  
  Two strings a and b are different if they either have different lengths or there exists such a position i that a_i ≠ b_i.
  
  A string a is lexicographically smaller than a string b if and only if one of the following holds: 
  
    * a is a prefix of b, but a ≠ b; 
    * in the first position where a and b differ, the string a has a letter that appears earlier in the alphabet than the corresponding letter in b. 
  
  
  
  Now consider all different BA-strings and find the x-th lexicographically smallest of them.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
  
  The first line of each testcase contains three integers n, k and x (1 ≤ n ≤ 2000; 0 ≤ k ≤ 2000; 1 ≤ x ≤ 10^{18}). n is the length of string s.
  
  The second line of each testcase is a string s. It consists of n characters, each of them is either 'a' (a lowercase Latin letter) or '*' (an asterisk).
  
  The sum of n over all testcases doesn't exceed 2000. For each testcase x doesn't exceed the total number of different BA-strings. String s contains at least one character 'a'.
  
  Output
  
  For each testcase, print a single string, consisting only of characters 'b' and 'a' (lowercase Latin letters) — the x-th lexicographically smallest BA-string.
  
  Example
  
  Input
  
  
  3
  2 4 3
  a*
  4 1 3
  a**a
  6 3 20
  **a***
  
  
  Output
  
  
  abb
  abba
  babbbbbbbbb
  
  Note
  
  In the first testcase of the example, BA-strings ordered lexicographically are: 
  
    1. a
    2. ab
    3. abb
    4. abbb
    5. abbbb
  
  
  
  In the second testcase of the example, BA-strings ordered lexicographically are: 
  
    1. aa
    2. aba
    3. abba
  
  
  
  Note that string "aba" is only counted once, even though there are two ways to replace asterisks with characters 'b' to get it.
solution: import java.io.BufferedReader;
  import java.io.IOException;
  import java.io.InputStreamReader;
  import java.util.ArrayList;
  import java.util.HashSet;
  import java.util.List;
  import java.util.StringTokenizer;
  
  public class C {
      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;
          }
      }
      public static void main(String[] args){
          FastReader sc = new FastReader();
          int t = sc.nextInt();
          StringBuilder s = new StringBuilder();
          while (t-->0){
               int n = sc.nextInt();
               int k = sc.nextInt();
               long x = sc.nextLong();
               String in = sc.next();
               long block = 0;
               int z = in.length();
               boolean[] isStar = new boolean[z];
               long[] numberB = new long[z];
  
               for (int i=0;i<z;i++){
                   if (in.charAt(i)=='*'){
                       isStar[i] = true;
                   }
               }
               x-=1;
              for (int i=z-1;i>=0;i--) {
                  if (isStar[i]) {
                      block += k;
                      if (i==0){
                          long r = x%(block+1);
                          x = x/(block+1);
                          numberB[i] = r;
                          block = 0;
                      }
                  }else {
                      if (block!=0){
                          long r = x%(block+1);
                          x = x/(block+1);
                          numberB[i+1] = r;
                          block = 0;
                      }
                  }
              }
               for (int i=0;i<z;i++){
                   if (in.charAt(i)=='a'){
                       s.append('a');
                   }else {
                       for (int j=0;j<numberB[i];j++){
                           s.append('b');
                       }
                   }
               }
               s.append('\n');
  
          }
          System.out.println(s);
      }
  
  }
  /***
   * 19%4 = 3
   * 16
   *
   *
   * */