description: You are given an integer n. Find any string s of length n consisting only of English lowercase letters such that each non-empty substring of s occurs in s an odd number of times. If there are multiple such strings, output any. It can be shown that such string always exists under the given constraints.
  
  A string a is a substring of a string b if a can be obtained from b by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 500) — the number of test cases.
  
  The first line of each test case contains a single integer n (1 ≤ n ≤ 10^5).
  
  It is guaranteed that the sum of n over all test cases doesn't exceed 3 ⋅ 10^5.
  
  Output
  
  For each test case, print a single line containing the string s. If there are multiple such strings, output any. It can be shown that such string always exists under the given constraints.
  
  Example
  
  Input
  
  
  4
  3
  5
  9
  19
  
  
  Output
  
  
  abc
  diane
  bbcaabbba
  youarethecutestuwuu
  
  Note
  
  In the first test case, each substring of "abc" occurs exactly once.
  
  In the third test case, each substring of "bbcaabbba" occurs an odd number of times. In particular, "b" occurs 5 times, "a" and "bb" occur 3 times each, and each of the remaining substrings occurs exactly once.
solution: import sys
  from math import *
  import builtins
  import string
  import bisect
  
  alphabets = list(string.ascii_lowercase)
  ALPHABETS = list(string.ascii_uppercase)
  
  # # For getting input from input.txt file
  # sys.stdin = open('input.txt', 'r')
  #
  # # Printing the Output to output.txt file
  # sys.stdout = open('output.txt', 'w')
  
  # input = sys.stdin.readline
  
  
  def print(x, end='\n'):
      sys.stdout.write(str(x) + end)
  
  
  # IO helpers
  def get_int():
      return int(input())
  
  
  def get_list_ints():
      return list(map(int, input().split()))
  
  
  def get_char_list():
      s = input()
      return list(s[:len(s)])
  
  
  def get_tuple_ints():
      return tuple(map(int, input().split()))
  
  
  def print_iterable(p):
      print(" ".join(map(str, p)))
  
  
  def floorSearch(arr, low, high, x):
      if low > high:
          return -1
      if x >= arr[high]:
          return high
      mid = int((low + high) / 2)
      if arr[mid] == x:
          return mid
      if mid > 0 and arr[mid - 1] <= x < arr[mid]:
          return mid - 1
      if x < arr[mid]:
          return floorSearch(arr, low, mid - 1, x)
      return floorSearch(arr, mid + 1, high, x)
  
  
  def binary_search(arr, x):
      low = 0
      high = len(arr) - 1
      mid = 0
      while low <= high:
          mid = (high + low) // 2
          if arr[mid] < x:
              low = mid + 1
          elif arr[mid] > x:
              high = mid - 1
          else:
              return mid
      return high
  
  
  def main():
      p = get_int()
      for q in range(p):
          n = get_int()
          k = int(n // 2)
          if n == 1:
              print("a")
          else:
              if n % 2 == 0:
                  ls = ['a' for y in range(k)] + ['b'] + ['a' for y in range(k-1)]
              else:
                  ls = ['a' for y in range(k)] + ['b', 'c'] + ['a' for y in range(k - 1)]
              s = "".join(y for y in ls)
              print(s)
      pass
  
  
  if __name__ == '__main__':
      main()
  