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: 
  def main():
      
      t = int(input())
      allans = []
      for _ in range(t):
          n, k, x = readIntArr()
          x -= 1
          s = input()
          cnts = 0
          arr = [] # store a or how many bs there can be in this place
          for i, c in enumerate(s):
              if c == 'a':
                  if cnts > 0:
                      arr.append(cnts * k)
                      cnts = 0
                  arr.append(c)
              else: # asterisk
                  cnts += 1
          if cnts > 0:
              arr.append(cnts * k)
          numIdxes = [] # numerical indexes
          cntsAtIdxes = []
          for i, c in enumerate(arr):
              if type(c) == int:
                  numIdxes.append(i)
                  cntsAtIdxes.append(c)
          m = len(numIdxes)
          suffixProducts = [1] * m # exclude itself
          suffixSum = 1
          for i in range(m - 1, -1, -1):
              suffixProducts[i] = suffixSum
              suffixSum += suffixProducts[i] * cntsAtIdxes[i]
              # suffixProducts[i] = suffixProducts[i + 1] * (cntsAtIdxes[i + 1] + 1)
          # every 1 at numIdxes[i] will increase ans by suffixProducts[i]
          
          requiredCnts = [0] * m
          for i in range(m):
              for j in range(cntsAtIdxes[i], -1, -1):
                  if j * suffixProducts[i] <= x:
                      requiredCnts[i] = j
                      x -= j * suffixProducts[i]
                      break
          ans = []
          j = 0
          for c in arr:
              if c == 'a':
                  ans.append('a')
              else:
                  for __ in range(requiredCnts[j]):
                      ans.append('b')
                  j += 1
          allans.append(''.join(ans))
          
      multiLineArrayPrint(allans)
      
      return
  
  
  import sys
  # input=sys.stdin.buffer.readline #FOR READING PURE INTEGER INPUTS (space separation ok)
  input=lambda: sys.stdin.readline().rstrip("\r\n") #FOR READING STRING/TEXT INPUTS.
  
  def oneLineArrayPrint(arr):
      print(' '.join([str(x) for x in arr]))
  def multiLineArrayPrint(arr):
      print('\n'.join([str(x) for x in arr]))
  def multiLineArrayOfArraysPrint(arr):
      print('\n'.join([' '.join([str(x) for x in y]) for y in arr]))
   
  def readIntArr():
      return [int(x) for x in input().split()]
  # def readFloatArr():
  #     return [float(x) for x in input().split()]
   
  def makeArr(defaultValFactory,dimensionArr): # eg. makeArr(lambda:0,[n,m])
      dv=defaultValFactory;da=dimensionArr
      if len(da)==1:return [dv() for _ in range(da[0])]
      else:return [makeArr(dv,da[1:]) for _ in range(da[0])]
   
  def queryInteractive(a, b, c):
      print('? {} {} {}'.format(a, b, c))
      sys.stdout.flush()
      return int(input())
   
  def answerInteractive(ansArr):
      print('! {}'.format(' '.join([str(x) for x in ansArr])))
      sys.stdout.flush()
   
  inf=float('inf')
  # MOD=10**9+7
  # MOD=998244353
  
  from math import gcd,floor,ceil
  import math
  # from math import floor,ceil # for Python2
   
  for _abc in range(1):
      main()