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.*;
  import java.util.*;
  import java.math.*;
  import java.lang.*;
   
  import static java.lang.Math.*;
  
  public class Main implements Runnable {
      static class InputReader {
          private InputStream stream;
          private byte[] buf = new byte[1024];
          private int curChar;
          private int numChars;
          private SpaceCharFilter filter;
          private BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
   
          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 String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              }
              catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
          public int nextInt() {
              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 long nextLong() {
              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 double nextDouble() {
              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, nextInt());
                  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, nextInt());
                      if (c < '0' || c > '9')
                          throw new InputMismatchException();
                      m /= 10;
                      res += (c - '0') * m;
                      c = read();
                  }
              }
              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 boolean isSpaceChar(int c) {
              if (filter != null)
                  return filter.isSpaceChar(c);
              return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
          }
       
          public String next() {
              return readString();
          }
          
          public interface SpaceCharFilter {
              public boolean isSpaceChar(int ch);
          }
      }
      public static void main(String args[]) throws Exception {
          new Thread(null, new Main(),"Main",1<<26).start();
      } 
      void solve() {
          InputReader sc = new InputReader(System.in);
          PrintWriter out = new PrintWriter(System.out);
  
          int t = sc.nextInt();
          for(int p = 0; p < t; ++p) {
              int n = sc.nextInt();
              int k = sc.nextInt();
              long x = sc.nextLong();
  
              char[] s = sc.next().toCharArray();
  
              List<Long> subtractions = new ArrayList<>();
              List<Long> possibility = new ArrayList<>();
              long curPossibility = 0;
              long cans = 1;
              long inf = (long)1e18 + 1;
              for(int i = n - 1; i >= 0; --i) {
                  if(s[i] == 'a') {
                      subtractions.add(cans);
                      if(inf / cans < curPossibility + 1) {
                          cans = inf;
                      }
                      else {
                          cans *= (curPossibility + 1);
                      }
  
                      possibility.add(curPossibility);
                      curPossibility = 0;
                  }
                  else {
                      curPossibility += k;
                  }
              }
  
              subtractions.add(cans);
              if(inf / cans < curPossibility + 1) {
                  cans = inf;
              }
              else {
                  cans *= (curPossibility + 1);
              }
  
              possibility.add(curPossibility);
              
              curPossibility = 0;
  
              long req = x - 1;
              List<Character> ans = new ArrayList<>();
              for(int i = possibility.size() - 1; i >= 0; --i) {
                  ans.add('a');
                  curPossibility = possibility.get(i);
                  long curSubtraction = subtractions.get(i);
  
                  // System.out.println(req + " " + curPossibility + " " + curSubtraction);
  
                  if(curSubtraction <= req) {
                      long possibleSubtractions = min(curPossibility, req / curSubtraction);
                      for(long j = 0; j < possibleSubtractions; ++j) {
                          ans.add('b');
                      }
                      req -= curSubtraction * possibleSubtractions;
                  }
              }
  
              char[] fans = new char[ans.size() - 1];
              for(int i = 1; i < ans.size(); ++i)
                  fans[i - 1] = ans.get(i);
  
              out.println(new String(fans));
          }
          out.close();
      }
      public void run() {
          solve();
      }
  }