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 os
  import sys
  from io import BytesIO, IOBase
  
  _print = print
  BUFSIZE = 8192
  
  
  def dbg(*args, **kwargs):
      _print('\33[95m', end='')
      _print(*args, **kwargs)
      _print('\33[0m', end='')
  
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          self._fd = file.fileno()
          self.buffer = BytesIO()
          self.writable = 'x' in file.mode or 'r' not in file.mode
          self.write = self.buffer.write if self.writable else None
  
      def read(self):
          while True:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              if not b:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
              self.newlines = b.count(b'\n') + (not b)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              os.write(self._fd, self.buffer.getvalue())
              self.buffer.truncate(0), self.buffer.seek(0)
  
  
  class IOWrapper(IOBase):
      def __init__(self, file):
          self.buffer = FastIO(file)
          self.flush = self.buffer.flush
          self.writable = self.buffer.writable
          self.write = lambda s: self.buffer.write(s.encode('ascii'))
          self.read = lambda: self.buffer.read().decode('ascii')
          self.readline = lambda: self.buffer.readline().decode('ascii')
  
  
  def inp():
      return sys.stdin.readline().rstrip()
  
  
  def mpint():
      return map(int, inp().split(' '))
  
  
  def itg():
      return int(inp())
  
  
  # ############################## import
  def split_consecutive(sorted_data, cmp=lambda a, b: a == b):
      result = []
      group = []
      prev = None
      for item in sorted_data:
          if not group or cmp(prev, item):
              group.append(item)
          else:
              result.append(group)
              group = [item]
          prev = item
      if group:
          result.append(group)
      return result
  
  
  # ############################## main
  from itertools import accumulate
  from operator import mul
  
  
  def solve():
      n, k, x = mpint()
      s = inp()
      nums = []
      group = split_consecutive(s)
      for lst in group:
          if lst[0] == '*':
              nums.append(len(lst) * k + 1)
      nums = list(accumulate(reversed(nums), mul))
      if nums:
          del nums[-1]
      nums.reverse()
      nums.append(1)
      # dbg(nums)
      x -= 1
      j = 0
      for i, lst in enumerate(group):
          if lst[0] == 'a':
              group[i] = 'a' * len(lst)
          else:
              q, x = divmod(x, nums[j])
              j += 1
              group[i] = 'b' * q
      return ''.join(group)
  
  
  def main():
      # print(solve())
      for _ in range(itg()):
          print(solve())
          # solve()
          # print("YES" if solve() else "NO")
          # print("yes" if solve() else "no")
  
  
  DEBUG = 0
  URL = 'https://codeforces.com/contest/1620/problem/C'
  
  if __name__ == '__main__':
      # 0: normal, 1: runner, 2: debug, 3: interactive
      if DEBUG == 1:
          import requests
          from ACgenerator.Y_Test_Case_Runner import TestCaseRunner
  
          runner = TestCaseRunner(main, URL)
          inp = runner.input_stream
          print = runner.output_stream
          runner.checking()
      else:
          if DEBUG != 2:
              dbg = lambda *args, **kwargs: ...
              sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
          if DEBUG == 3:
              def print(*args, **kwargs):
                  _print(*args, **kwargs)
                  sys.stdout.flush()
          main()
  # Please check!
  