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 static java.lang.Math.*;
  
  import java.util.*;
  import java.io.*;
  
  public class Solution {
  
      public static String find(int n, int k, long x, String s) {
          ArrayList<Integer> al = new ArrayList<>();
          int track = 0;
          while (track < n) {
              if (s.charAt(track) == 'a') {
                  int count = 0;
                  while (track < n && s.charAt(track) == 'a') {
                      count++;
                      track++;
                  }
                  al.add(-count);
              }
              else {
                  int count = 0;
                  while (track < n && s.charAt(track) == '*') {
                      count++;
                      track++;
                  }
                  al.add(count*k);
              }
          }
  //        System.out.println(al);
          Collections.reverse(al);
          StringBuilder res = new StringBuilder();
          x--;
          for (int i: al) {
              if (i < 0) {
                  while (i < 0) {
                      res.append('a');
                      i++;
                  }
              }
              else {
                  long rem = x%(i + 1);
                  while (rem > 0) {
                      res.append('b');
                      rem--;
                  }
                  x /= i+1;
              }
          }
          return res.reverse().toString();
      }
  
      public static void main(String[] args) {
          InputReader fs = new InputReader(System.in);
          PrintWriter pw = new PrintWriter(System.out);
          int t = fs.readInt();
          for (int tt = 0; tt < t; tt++) {
              int n = fs.readInt();
              int k = fs.readInt();
              long x = fs.readLong();
              String s = fs.readString();
              pw.println(find(n, k, x, s));
          }
  
          pw.flush();
          pw.close();
      }
  
      static class InputReader
      {
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int curChar;
          private int numChars;
          private SpaceCharFilter filter;
  
          public InputReader(InputStream stream)
          {
              this.stream = stream;
          }
  
          public int read() {
              if (numChars == -1)
                  throw new InputMismatchException();
              if (curChar >= numChars)
              {
                  curChar = 0;
                  try
                  {
                      numChars = stream.read(buf);
                  }
                  catch (IOException e)
                  {
                      throw new InputMismatchException();
                  }
                  if (numChars <= 0)
                      return -1;
              }
              return buf[curChar++];
          }
  
          public int readInt() {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              int sgn = 1;
              if (c == '-')
              {
                  sgn = -1;
                  c = read();
              }
              int res = 0;
              do
              {
                  if (c < '0' || c > '9')
                      throw new InputMismatchException();
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public String readString() {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              StringBuilder res = new StringBuilder();
              do
              {
                  res.appendCodePoint(c);
                  c = read();
              } while (!isSpaceChar(c));
              return res.toString();
          }
  
          public double readDouble() {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              int sgn = 1;
              if (c == '-')
              {
                  sgn = -1;
                  c = read();
              }
              double res = 0;
              while (!isSpaceChar(c) && c != '.')
              {
                  if (c == 'e' || c == 'E')
                      return res * Math.pow(10, readInt());
                  if (c < '0' || c > '9')
                      throw new InputMismatchException();
                  res *= 10;
                  res += c - '0';
                  c = read();
              }
              if (c == '.')
              {
                  c = read();
                  double m = 1;
                  while (!isSpaceChar(c))
                  {
                      if (c == 'e' || c == 'E')
                          return res * Math.pow(10, readInt());
                      if (c < '0' || c > '9')
                          throw new InputMismatchException();
                      m /= 10;
                      res += (c - '0') * m;
                      c = read();
                  }
              }
              return res * sgn;
          }
  
          public long readLong() {
              int c = read();
              while (isSpaceChar(c))
                  c = read();
              int sgn = 1;
              if (c == '-')
              {
                  sgn = -1;
                  c = read();
              }
              long res = 0;
              do
              {
                  if (c < '0' || c > '9')
                      throw new InputMismatchException();
                  res *= 10;
                  res += c - '0';
                  c = read();
              } while (!isSpaceChar(c));
              return res * sgn;
          }
  
          public boolean isSpaceChar(int c) {
              if (filter != null)
                  return filter.isSpaceChar(c);
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
          public int[] readIntArray(int n) {
              int[] a = new int[n];
              for (int i = 0; i < n; i++) {
                  a[i] = readInt();
              }
              return a;
          }
          public int[] readIntArrayShifted(int n) {
              int[] a = new int[n + 1];
              for (int i = 0; i < n; i++) {
                  a[i + 1] = readInt();
              }
              return a;
          }
          public long[] readLongArray(int n) {
              long[] a = new long[n];
              for (int i = 0; i < n; i++) {
                  a[i] = readLong();
              }
              return a;
          }
          public String next() {
              return readString();
          }
  
          interface SpaceCharFilter {
              public boolean isSpaceChar(int ch);
          }
      }
  
  }