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.util.*;
  import java.io.*;
  
  ////***************************************************************************
   /* public class E_Gardener_and_Tree implements Runnable{
  
         public static void main(String[] args) throws Exception {
          new Thread(null, new E_Gardener_and_Tree(), "E_Gardener_and_Tree", 1<<28).start();
         }
      public void run(){
           WRITE YOUR CODE HERE!!!!
           JUST WRITE EVERYTHING HERE WHICH YOU WRITE IN MAIN!!!
         }
  
    }
  */
  /////**************************************************************************
  
  
  public class C_BA_String{
      public static void main(String[] args) {
          FastScanner s= new FastScanner();
          //PrintWriter out=new PrintWriter(System.out);
          //end of program
          //out.println(answer);
          //out.close();
  
          StringBuilder res = new StringBuilder();
          int t=s.nextInt();
          int p=0;
          while(p<t){
          int n=s.nextInt();
          long k=s.nextLong();
          long x=s.nextLong();
          String str=s.nextToken();
          if(k==0){
              for(int i=0;i<str.length();i++){
                  char ch=str.charAt(i);
                  if(ch=='a'){
                      res.append(ch);
                  }
              }
              res.append(" \n");
              p++;
              continue;
          }
          int size=0;
          char prev='l';
          for(int i=0;i<n;i++){
              char ch=str.charAt(i);
              if(ch!='*'&& prev=='*'){
                  size++;
              }
              prev=ch;
          }
          if(prev=='*'){
              size++;
          }
          long array[]= new long[size];
          long count=0;
          prev='l';
          int yo=0;
          for(int i=0;i<n;i++){
              char ch=str.charAt(i);
              if(ch=='*'){
                  count++;
              }
              else{
                  if(prev=='*'){
                       array[yo]=count;
                       count=0;
                       yo++;
                  }
              }
              prev=ch;
          }
          if(count>0){
              array[yo]=count;
          }
          long nice[]= new long[size];
          long num=x;
          while(num>1){
              long flag[]= new long[1];
              solve(array,k,num,flag,nice);
              num=flag[0];
              flag=new long[1];
          }
          int yo1=0;
          char prev1='l';
          for(int i=0;i<n;i++){
               char ch=str.charAt(i);
               if(ch=='a'){
                   res.append(ch);
               }
               else{
                   if(prev1!='*'){
                       int num3=(int)nice[yo1];
                       for(int j=0;j<num3;j++){
                           res.append('b');
                       }
                       yo1++;
  
                   }
               }
               prev1=ch;
          }
          res.append(" \n");
          p++;
      }
      System.out.println(res);
  
  
  
  
  
  
      }
      private static void solve(long[] array, long k, long num, long[] flag, long nice[]) {
  
          int size=array.length;
          long prevsum=0;
          int check=0;
          long val2=0;
          for(int i=size-1;i>=0;i--){
               long val=(k*array[i]);
               if(i==size-1){
                   val++;
                   if(val>=num){
                       check=1;
                       break;
                   }
                   prevsum=val;
                   continue;
               }
               long big=power(10,18)+10;
               long yoyo3=big/prevsum;
               int check3=0;
               if(val>yoyo3){
                   check3=1;
               }
               long hh1=(val*prevsum);
               long nsum=hh1+prevsum;
               if(num>nsum && check3==0){
                   prevsum=nsum;
               }
               else{
                   long jj1=num-prevsum;
                   long jj2=jj1/prevsum;
                   if(jj1%prevsum!=0){
                       jj2++;
                   }
                   nice[i]=jj2;
                   val2=(jj2*prevsum);
                   break;
  
               }
          }
          if(check==1){
              nice[size-1]=(num-1);
              val2=num;
          }
          flag[0]=num-val2;
  
      }
      static class FastScanner {
  		BufferedReader br;
  		StringTokenizer st;
   
  		public FastScanner(String s) {
  			try {
  				br = new BufferedReader(new FileReader(s));
  			} catch (FileNotFoundException e) {
  				// TODO Auto-generated catch block
  				e.printStackTrace();
  			}
  		}
   
  		public FastScanner() {
  			br = new BufferedReader(new InputStreamReader(System.in));
  		}
   
  		String nextToken() {
  			while (st == null || !st.hasMoreElements()) {
  				try {
  					st = new StringTokenizer(br.readLine());
  				} catch (IOException e) {
  					// TODO Auto-generated catch block
  					e.printStackTrace();
  				}
  			}
  			return st.nextToken();
  		}
   
  		int nextInt() {
  			return Integer.parseInt(nextToken());
  		}
   
  		long nextLong() {
  			return Long.parseLong(nextToken());
  		}
   
  		double nextDouble() {
  			return Double.parseDouble(nextToken());
  		}
  	}
  
  
      static long modpower(long x, long y, long p)
       {
        long res = 1; // Initialize result
     
        x = x % p; // Update x if it is more than or
        // equal to p
     
        if (x == 0)
          return 0; // In case x is divisible by p;
     
        while (y > 0)
        {
     
          // If y is odd, multiply x with result
          if ((y & 1) != 0)
            res = (res * x) % p;
     
          // y must be even now
          y = y >> 1; // y = y/2
          x = (x * x) % p;
        }
        return res;
      }
  
    
     // SIMPLE POWER FUNCTION=>
  
  
        static long power(long x, long y)
          {
              long res = 1;     // Initialize result
          
              while (y > 0)
              {
              
                  // If y is odd, multiply x with result
                  if ((y & 1) != 0)
                      res = res * x;
          
                  // y must be even now
                  y = y >> 1; // y = y/2
                  x = x * x;  // Change x to x^2
              }
              return res;
          }
  
  
  
  
  
  }