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: #include <bits/stdc++.h>
  namespace jr_zlw {
  inline __int128 read() {
    __int128 res = 0;
    char ch = getchar();
    bool flag = 0;
    while (ch < '0' || ch > '9') flag ^= (ch == '-'), ch = getchar();
    while (ch <= '9' && ch >= '0') res = res * 10 + (ch ^ 48), ch = getchar();
    return flag ? -res : res;
  }
  template <typename T>
  inline T min(T x, T y) {
    return x < y ? x : y;
  }
  template <typename T>
  inline T max(T x, T y) {
    return y < x ? x : y;
  }
  template <typename T>
  inline void Swap(T &x, T &y) {
    T tmp = x;
    x = y;
    y = tmp;
  }
  template <typename T>
  inline T abs(T x) {
    return x < 0 ? -x : x;
  }
  template <typename T>
  inline void rd(T &x) {
    x = 0;
    char ch = getchar();
    bool flag = 0;
    while (ch < '0' || ch > '9') flag ^= (ch == '-'), ch = getchar();
    while (ch <= '9' && ch >= '0') x = x * 10 + (ch ^ 48), ch = getchar();
    flag ? x = -x : 0;
  }
  inline char rdLow() {
    char ch;
    do ch = getchar();
    while (ch < 'a' || ch > 'z');
    return ch;
  }
  inline char rdHigh() {
    char ch;
    do ch = getchar();
    while (ch < 'A' || ch > 'Z');
    return ch;
  }
  inline bool rdBool() {
    char ch;
    do ch = getchar();
    while (ch != '0' && ch != '1');
    return ch ^ 48;
  }
  inline __int128 rdStr(char *s) {
    __int128 p = 0;
    char ch;
    do ch = getchar();
    while (ch == ' ' || ch == '\n' || ch == '\r');
    while (ch != ' ' && ch != '\n' && ch != '\r' && ~ch)
      s[++p] = ch, ch = getchar();
    return p;
  }
  template <typename T>
  inline void print(T p) {
    if (p > 9) print(p / 10);
    putchar(p % 10 + '0');
  }
  template <typename T>
  inline void Print(T p, char ch) {
    print(p);
    putchar(ch);
  }
  const __int128 N = 2010;
  char s[N];
  __int128 a[N];
  __int128 dp[N], p, L[N], R[N];
  inline void mian() {
    __int128 n = read(), k = read(), x = read() - 1;
    scanf("%s", s + 1);
    for (__int128 i = (1); i <= (n); ++i) a[i] = (s[i] == 'a' ? 1 : 0);
    p = 1;
    R[1] = n;
    dp[1] = 0;
    for (__int128 i = (n); i >= (1); --i)
      if (s[i] == '*')
        dp[p]++, L[p] = i;
      else if (dp[p])
        R[++p] = i - 1, dp[p] = 0;
    for (__int128 i = (1); i <= (p); ++i) dp[i] = dp[i] * k + 1;
    while (x) {
      __int128 res = 1;
      for (__int128 i = (1); i <= (p); ++i) {
        if (dp[i] * res > x) {
          if (i == 1) {
            a[L[1]] = x;
            x = 0;
            break;
          }
          a[L[i]] = x / res;
          x %= res;
          break;
        }
        res = res * dp[i];
      }
    }
    for (__int128 i = (1); i <= (n); ++i)
      for (__int128 j = (1); j <= (a[i]); ++j) putchar(s[i] == 'a' ? 'a' : 'b');
    puts("");
  }
  }  // namespace jr_zlw
  signed main() {
    __int128 T = jr_zlw::read();
    while (T--) jr_zlw::mian();
    return 0;
  }
  