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: # cook your dish here
  import sys
  import bisect
  from bisect import bisect_left as lb
  from bisect import bisect_right as rb
  input_=lambda: sys.stdin.readline().strip("\r\n")
  from math import log
  from math import gcd
  from math import atan2,acos
  from random import randint
  sa=lambda :input_()
  sb=lambda:int(input_())
  sc=lambda:input_().split()
  sd=lambda:list(map(int,input_().split()))
  sflo=lambda:list(map(float,input_().split()))
  se=lambda:float(input_())
  sf=lambda:list(input_())
  flsh=lambda: sys.stdout.flush()
  sys.setrecursionlimit(3*10**5)
  mod=10**9+7
  mod1=998244353
  gp=[]
  cost=[]
  dp=[]
  mx=[]
  ans1=[]
  ans2=[]
  special=[]
  specnode=[]
  a=0
  kthpar=[]
  def dfs2(root,par):
      if par!=-1:
          dp[root]=dp[par]+1
      for i in range(1,20):
          if kthpar[root][i-1]!=-1:
              kthpar[root][i]=kthpar[kthpar[root][i-1]][i-1]
      for child in gp[root]:
          if child==par:continue
          kthpar[child][0]=root
          dfs(child,root)
          
  ans=0
  a=[]
  n,k=0,0
  b=[]
  vis=[]
  tot=0
  time=[]
  time1=[]
  adj=[]
  mx=-1
  eps=0.0000001
  x=0
  pref=[]
  lvl=[]
  gp=[]
  ans=[]
  f=0
  w=[]
  
  def dfs(i,prod,rem,n):
      if rem==0:
          while(i<len(n)):
              prod*=int(n[i])
              i+=1
          return prod
      if i==len(n):
          return prod
      mx=0
      for j in range(9-int(n[i])):
          mx=max(dfs(i+1,(int(n[i])+min(j,rem))*prod,rem-min(j,rem),n),mx)
      return mx
  class Disjoint_SU:
      def __init__(self,n):
          self.parent=[i for i in range(n)]
          self.size=[1 for i in range(n)]
      #find
      def lake_de(self,a):
          if a==self.parent[a]:
              return a
          self.parent[a]=self.lake_de(self.parent[a])
          return self.parent[a]
      #union
      #by size
      def jod(self,a,b):
          x=self.lake_de(a)
          y=self.lake_de(b)
          #for cycle in graph
          if x==y:
              return True
          if self.size[x]>self.size[y]:
              self.size[x]+=self.size[y]
              self.parent[y]=x
          else:
              self.size[y]+=self.size[x]
              self.parent[x]=y
          return False
  def hnbhai(tc):
      n,k,x=sd()
      a=sa()
      stck=[]
      tot=0
      are=[]
      for i in range(n):
          if a[i]=="*":
              tot+=1
          else:
              if tot!=0:
                  are.append(["b",k*tot+1])
              tot=0
              are.append(["a",1])
      if tot!=0:
          are.append(["b",k*tot+1])
      suffix=[1]*(n+1)
      for i in range(len(are)-1,-1,-1):
          suffix[i]=suffix[i+1]*(are[i][1])
          suffix[i]=min(10**19,suffix[i])
      #x-=1
      ans=[]
      for i in range(len(are)):
          if are[i][0]=="b":
              for j in range(are[i][1]):
                  if (j+1)*suffix[i+1]>=x:
                      ans.append("b"*j)
                      #print(x)
                      x-=j*suffix[i+1]
                      break
          else:
              ans.append(are[i][0])
      print("".join(ans))
      return
  for _ in range(sb()):
      hnbhai(_+1)
  ##case
  
  #.
  