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.

Difficulty: MEDIUM_HARD

Solutions:
for testis in range(int(input())):
	n = int(input())
	if n == 1:
		print('a')
	else:
		s = 'a' * (n // 2)
		if n & 1:
			s += 'bc'
		else:
			s += 'b'
		s += 'a' * (n // 2 - 1)
		print(s)


for _ in range(int(input())):
	n = int(input())
	print('a' * (n // 2) + 'b' + 'a' * max(0, n // 2 - 1) if n % 2 == 0 or n == 1 else 'a' * (n // 2) + 'bc' + 'a' * (n // 2 - 1))


for _ in range(int(input())):
	n = int(input())
	print('a' if n == 1 else 'a' * (n // 2) + ('bc' if n % 2 else 'b') + 'a' * (n // 2 - 1))


import math
import os
import random
import re
import sys
from collections import defaultdict

def get_ints():
	return list(map(int, sys.stdin.readline().strip().split()))

def get_string():
	return sys.stdin.readline().strip()
t = int(input())
for test in range(t):
	n = int(input())
	if n == 1:
		sys.stdout.write('a\n')
		continue
	k = n // 2
	s = 'a' * k
	if n > 1:
		if n % 2 == 0:
			s += 'b'
		else:
			s += 'bc'
	s += 'a' * (k - 1)
	sys.stdout.write(s + '\n')


__T = int(input())
for _ in range(__T):
	n = int(input())
	k = n // 2
	if n == 1:
		print('a')
	elif n % 2 == 0:
		print('a' * k + 'b' + 'a' * (k - 1))
	else:
		print('a' * k + 'bc' + 'a' * (k - 1))


from sys import stdin, stdout
import math

def get_list():
	return list(map(int, stdin.readline().strip().split()))

def get_int():
	return int(stdin.readline())

def get_ints():
	return map(int, stdin.readline().strip().split())

def get_string():
	return stdin.readline()

def printn(n):
	stdout.write(str(n) + '\n')

def solve():
	n = get_int()
	x = n // 2
	if n == 1:
		printn('a')
		return
	if n % 2:
		s = ''.join(['a' * x, 'bc', 'a' * (x - 1)])
		printn(s)
	else:
		s = ''.join(['a' * x, 'b', 'a' * (x - 1)])
		printn(s)
t = get_int()
while t:
	t -= 1
	solve()


import sys
input = sys.stdin.buffer.readline
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print('a')
	elif n == 2:
		print('ab')
	elif n % 2:
		print('a' * (n // 2) + 'bc' + 'a' * (n // 2 - 1))
	else:
		print('a' * (n // 2) + 'b' + 'a' * (n // 2 - 1))


t = int(input())
for laskjkljfsd in range(t):
	n = int(input())
	if n % 2:
		if n == 1:
			print('a')
		else:
			print('a' * (n // 2) + 'bc' + 'a' * (n // 2 - 1))
	else:
		print('a' * (n // 2) + 'b' + 'a' * (n // 2 - 1))


import sys
input = sys.stdin.buffer.readline
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		ans = 'a'
	elif n % 2 == 0:
		k = n // 2
		ans = 'a' * k + 'b' + 'a' * (k - 1)
	else:
		k = (n - 1) // 2
		ans = 'a' * k + 'bc' + 'a' * (k - 1)
	print(ans)


t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print('a')
	elif n == 2:
		print('ab')
	elif n == 3:
		print('abc')
	elif n % 2 == 0:
		print('a' * (n // 2) + 'b' + 'a' * (n // 2 - 1))
	else:
		print('a' * (n // 2) + 'bc' + 'a' * (n // 2 - 1))


from collections import defaultdict
import math
for cases in range(int(input())):
	n = int(input())
	ans = ''
	if n == 1:
		print('a')
	elif n % 2 != 0:
		n = n - 2
		ans = 'a' * (n // 2 + 1) + 'bc' + 'a' * (n // 2)
	else:
		n = n - 1
		ans = 'a' * (n // 2 + 1) + 'b' + 'a' * (n // 2)
	print(ans)


from sys import stdin
input = stdin.readline

def answer():
	(ans, x) = ('', n // 2)
	if n & 1 == 0:
		ans = 'a' * x + 'b' + 'a' * (x - 1)
	else:
		if n == 1:
			return 'a'
		ans = 'a' * x + 'b' + 'c' + 'a' * (x - 1)
	return ans
for T in range(int(input())):
	n = int(input())
	print(answer())


for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print('a')
	elif n % 2 == 0:
		m = 'a' * ((n - 2) // 2)
		print(f'a{m}b{m}')
	else:
		m = 'a' * ((n - 3) // 2)
		print(f'a{m}bc{m}')


from math import *
from decimal import *
from decimal import Decimal as D
from string import ascii_lowercase as lc
from string import ascii_uppercase as uc
from itertools import *
from itertools import permutations as perm
from itertools import product as prod
from sys import *
ip = input
ra = lambda : list(map(int, input().split()))
ri = lambda : int(input())
rd = lambda : map(int, input().split())
MOD = 10 ** 9 + 7
MOD2 = 998244353

def debug(*a):
	stderr.write(' '.join(map(str, a)) + '\n')

def fp(x, p, m):
	r = 1
	while p:
		if p % 2:
			r = r * x % m
			p -= 1
		else:
			x = x * x % m
			p //= 2
	return r

def fact(x, m):
	r = 1
	for i in range(2, x + 1):
		r = r * i % m
	return r

def C(n, k, m):
	return fact(n, m) * fp(fact(n - k, m), m - 2, m) % m * fp(fact(k, m), m - 2, m) % m

class SegmentTree:

	def f(self, a, b):
		return a + b

	def __init__(self, n, a):
		self.tree = [0] * (2 * n)
		self.n = n
		for i in range(n):
			self.tree[n + i] = a[i]
		for i in range(n - 1, 0, -1):
			self.tree[i] = self.f(self.tree[2 * i], self.tree[2 * i + 1])

	def q(self, l, r):
		l += self.n
		r += self.n
		res = 0
		while r > 1:
			if l % 2:
				res = self.f(res, self.tree[l])
				l += 1
			if r % 2:
				r -= 1
				res = self.f(res, self.tree[r])
			r //= 2
			l //= 2
		return res

	def u(self, index, value):
		index += self.n
		self.tree[index] = value
		index //= 2
		while index > 0:
			self.tree[index] = self.f(self.tree[2 * index], self.tree[2 * index + 1])
			index //= 2

def z_function(s):
	(l, r, n) = (0, 0, len(s))
	z = [0] * n
	z[0] = 0
	for i in range(1, n):
		if r >= i:
			z[i] = min(z[i - l], r - i + 1)
		while z[i] + i < n and s[z[i]] == s[z[i] + i]:
			z[i] += 1
		if i + z[i] - 1 > r:
			l = i
			r = l + z[i] - 1
	return z

def pc_pre(a):
	n = len(a)
	r = [0] * (n + 1)
	for i in range(n):
		r[i + 1] = r[i] + a[i]
	return r

def pc_suf(a):
	n = len(a)
	r = [0] * (n + 1)
	for i in range(n - 1, -1, -1):
		r[i] = r[i + 1] + a[i]
	return r

def bsloe(a, v):
	(l, h) = (-1, len(a))
	while h - l > 1:
		m = (h + l) // 2
		if a[m] > v:
			h = m
		else:
			l = m
	return l

def bsh(a, v):
	(l, h) = (-1, len(a))
	while h - l > 1:
		m = (h + l) // 2
		if a[m] > v:
			h = m
		else:
			l = m
	return h

def test():
	a = [1, 2, 3]
	s = 'abcabcab'
	assert C(3, 2, 5) == 3
	assert pc_pre(a) == [0, 1, 3, 6]
	assert pc_suf(a) == [6, 5, 3, 0]
	assert z_function(s) == [0, 0, 0, 5, 0, 0, 2, 0]
	assert fp(2, 3, 5) == 3
	assert fact(3, 5) == 1
	t = SegmentTree(3, a)
	assert t.q(1, 3) == t.f(a[1], a[2])
	t.u(0, 5)
	assert t.q(0, 2) == t.f(5, a[1])
	assert bsh(a, 3) == 3
	assert bsloe(a, 3) == 2
	debug('tests passed')
test()

def solve(n):
	if n == 1:
		print('a')
	elif n % 2 == 0:
		print('a' * (n // 2) + 'b' + 'a' * (n // 2 - 1))
	else:
		print('a' * (n // 2) + 'bc' + 'a' * (n // 2 - 1))
(t,) = rd()
for _ in range(t):
	(n,) = rd()
	solve(n)


import io, os
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline

def main(t):
	n = int(input())
	if n == 1:
		ans = 'a'
	elif n == 2:
		ans = 'ab'
	elif n == 3:
		ans = 'abc'
	elif n % 2 == 1:
		num = n // 2 - 1
		ans = 'a' * (num + 1) + 'bc' + 'a' * num
	elif n % 2 == 0:
		num = n // 2 - 1
		ans = 'a' * (num + 1) + 'b' + 'a' * num
	print(ans)
T = int(input())
t = 1
while t <= T:
	main(t)
	t += 1


T = int(input())
for _ in range(T):
	n = int(input())
	A = []
	if n == 1:
		print('a')
		continue
	A.append('a' * (n // 2))
	if n % 2 == 0:
		A.append('b')
	else:
		A.append('bc')
	A.append('a' * (n // 2 - 1))
	print(''.join(A))


def TestCase():
	n = int(input())
	if n == 1:
		print('a')
	else:
		s = 'a' * (n // 2)
		if n & 1:
			s += 'bc'
		else:
			s += 'b'
		s += 'a' * (n // 2 - 1)
		print(s)
t = int(input())
for _ in range(t):
	TestCase()


try:
	import sys
	from functools import lru_cache, cmp_to_key
	from heapq import merge, heapify, heappop, heappush
	from math import *
	from collections import defaultdict as dd, deque, Counter as C
	from itertools import combinations as comb, permutations as perm
	from bisect import bisect_left as bl, bisect_right as br, bisect, insort
	from time import perf_counter
	from fractions import Fraction
	import copy
	from copy import deepcopy
	import time
	starttime = time.time()
	mod = int(pow(10, 9) + 7)
	mod2 = 998244353

	def data():
		return sys.stdin.readline().strip()

	def out(*var, end='\n'):
		sys.stdout.write(' '.join(map(str, var)) + end)

	def L():
		return list(sp())

	def sl():
		return list(ssp())

	def sp():
		return map(int, data().split())

	def ssp():
		return map(str, data().split())

	def l1d(n, val=0):
		return [val for i in range(n)]

	def l2d(n, m, val=0):
		return [l1d(n, val) for j in range(m)]

	def A2(n, m):
		return [[0] * m for i in range(n)]

	def A(n):
		return [0] * n
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
for _ in range(L()[0]):
	n = int(input())
	if n == 1:
		print('a')
	else:
		s = 'a' * (n // 2)
		if n & 1:
			s += 'bc'
		else:
			s += 'b'
		s += 'a' * (n // 2 - 1)
		print(s)


import math
import heapq
import string
from collections import deque
import sys
input = sys.stdin.readline
S = lambda : input()
I = lambda : int(S())
M = lambda : map(int, S().split())
L = lambda : list(M())
H = 1000000000 + 7
for _ in range(I()):
	n = I()
	if n == 1:
		print('a')
	elif n % 2 == 0:
		k = n // 2
		print('a' * k + 'b' + 'a' * (k - 1))
	else:
		k = n // 2
		print('a' * k + 'bc' + 'a' * (k - 1))


import sys, math
import heapq
from collections import deque
input = sys.stdin.readline

def ip():
	return int(input())

def fp():
	return float(input())

def sp():
	return str(input().rstrip())

def mip():
	return map(int, input().split())

def msp():
	return map(str, input().split())

def lmip():
	return list(map(int, input().split()))

def lmsp():
	return list(map(str, input().split()))

def gcd(x, y):
	while y:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	return x * y // gcd(x, y)

def isprime(x):
	if x == 1:
		return False
	for i in range(2, int(x ** 0.5) + 1):
		if x % i == 0:
			return False
	return True

def find(x):
	if x == p[x]:
		return x
	q = find(p[x])
	p[x] = q
	return q

def union(x, y):
	global n
	x = find(x)
	y = find(y)
	if x != y:
		p[y] = x
t = ip()
while t:
	t -= 1
	n = ip()
	s = ['a'] * n
	if n & 1 and n > 1:
		s[n // 2 + 1] = 'c'
	s[n // 2] = 'b'
	print(*s, sep='')


t = int(input())
for _ in range(t):
	n = int(input())
	if n == 1:
		print('a')
		continue
	ans = 'a' * (n // 2)
	if n % 2 == 1:
		ans += 'bc'
	else:
		ans += 'b'
	ans += 'a' * (n // 2 - 1)
	print(ans)


import sys
input = lambda : sys.stdin.readline().rstrip('\r\n')
inp = lambda : list(map(int, sys.stdin.readline().rstrip('\r\n').split()))
mod = 10 ** 9 + 7
Mod = 998244353
INF = float('inf')
import math
from bisect import *
from heapq import *
from collections import defaultdict as dd
from collections import OrderedDict as odict
from collections import Counter as cc
from collections import deque
from itertools import groupby
sys.setrecursionlimit(20 * 20 * 20 * 20 + 10)

def solve():
	n = takein()
	if n == 1:
		print('a')
		return
	ans = 'a' * (n // 2)
	if n % 2 == 0:
		ans += 'b'
	else:
		ans += 'bc'
	ans += 'a' * (n // 2 - 1)
	print(ans)

def main():
	global tt
	if not ONLINE_JUDGE:
		sys.stdin = open('input.txt', 'r')
		sys.stdout = open('output.txt', 'w')
	t = 1
	t = takein()
	for tt in range(1, t + 1):
		solve()
	if not ONLINE_JUDGE:
		print('Time Elapsed :', time.time() - start_time, 'seconds')
		sys.stdout.close()

def takein():
	return int(sys.stdin.readline().rstrip('\r\n'))

def takesr():
	return sys.stdin.readline().rstrip('\r\n')

def takeiar():
	return list(map(int, sys.stdin.readline().rstrip('\r\n').split()))

def takesar():
	return list(map(str, sys.stdin.readline().rstrip('\r\n').split()))

def takeivr():
	return map(int, sys.stdin.readline().rstrip('\r\n').split())

def takesvr():
	return map(str, sys.stdin.readline().rstrip('\r\n').split())

def ispalindrome(s):
	return s == s[::-1]

def invert(bit_s):
	temp = int(bit_s, 2)
	inverse_s = temp ^ 2 ** (len(bit_s) + 1) - 1
	rslt = bin(inverse_s)[3:]
	return str(rslt)

def counter(a):
	q = [0] * max(a)
	for i in range(len(a)):
		q[a[i] - 1] = q[a[i] - 1] + 1
	return q

def counter_elements(a):
	q = dict()
	for i in range(len(a)):
		if a[i] not in q:
			q[a[i]] = 0
		q[a[i]] = q[a[i]] + 1
	return q

def string_counter(a):
	q = [0] * 26
	for i in range(len(a)):
		q[ord(a[i]) - 97] = q[ord(a[i]) - 97] + 1
	return q

def factorial(n, m=1000000007):
	q = 1
	for i in range(n):
		q = q * (i + 1) % m
	return q

def factors(n):
	q = []
	for i in range(1, int(n ** 0.5) + 1):
		if n % i == 0:
			q.append(i)
			q.append(n // i)
	return list(sorted(list(set(q))))

def prime_factors(n):
	q = []
	while n % 2 == 0:
		q.append(2)
		n = n // 2
	for i in range(3, int(n ** 0.5) + 1, 2):
		while n % i == 0:
			q.append(i)
			n = n // i
	if n > 2:
		q.append(n)
	return list(sorted(q))

def transpose(a):
	(n, m) = (len(a), len(a[0]))
	b = [[0] * n for i in range(m)]
	for i in range(m):
		for j in range(n):
			b[i][j] = a[j][i]
	return b

def power_two(x):
	return x and (not x & x - 1)

def ceil(a, b):
	return -(-a // b)

def seive(n):
	a = [1]
	prime = [True for i in range(n + 1)]
	p = 2
	while p * p <= n:
		if prime[p] == True:
			for i in range(p ** 2, n + 1, p):
				prime[i] = False
		p = p + 1
	for p in range(2, n + 1):
		if prime[p]:
			a.append(p)
	return a

def pref(li):
	pref_sum = [0]
	for i in li:
		pref_sum.append(pref_sum[-1] + i)
	return pref_sum

def kadane(x):
	sum_so_far = 0
	current_sum = 0
	for i in x:
		current_sum += i
		if current_sum < 0:
			current_sum = 0
		else:
			sum_so_far = max(sum_so_far, current_sum)
	return sum_so_far

def binary_search(li, val):
	ans = -1
	lb = 0
	ub = len(li) - 1
	while lb <= ub:
		mid = (lb + ub) // 2
		if li[mid] > val:
			ub = mid - 1
		elif val > li[mid]:
			lb = mid + 1
		else:
			ans = mid
			break
	return ans

def upper_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] <= num:
			answer = middle
			start = middle + 1
		else:
			end = middle - 1
	return answer

def lower_bound(li, num):
	answer = -1
	start = 0
	end = len(li) - 1
	while start <= end:
		middle = (end + start) // 2
		if li[middle] >= num:
			answer = middle
			end = middle - 1
		else:
			start = middle + 1
	return answer
ONLINE_JUDGE = __debug__
if ONLINE_JUDGE:
	input = sys.stdin.readline
main()


from bisect import insort, bisect_right, bisect_left
from sys import stdout, stdin, setrecursionlimit
from heapq import heappush, heappop, heapify
from io import BytesIO, IOBase
from collections import *
from itertools import *
from random import *
from string import *
from queue import *
from math import *
from re import *
from os import *

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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
			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 = read(self._fd, max(fstat(self._fd).st_size, 8192))
			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:
			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')
(stdin, stdout) = (IOWrapper(stdin), IOWrapper(stdout))
(graph, mod, szzz) = ({}, 10 ** 9 + 7, lambda : sorted(zzz()))

def getStr():
	return input()

def getInt():
	return int(input())

def listStr():
	return list(input())

def getStrs():
	return input().split()

def isInt(s):
	return '0' <= s[0] <= '9'

def input():
	return stdin.readline().strip()

def zzz():
	return [int(i) for i in input().split()]

def output(answer, end='\n'):
	stdout.write(str(answer) + end)

def lcd(xnum1, xnum2):
	return xnum1 * xnum2 // gcd(xnum1, xnum2)

def getPrimes(N=10 ** 5):
	SN = int(sqrt(N))
	sieve = [i for i in range(N + 1)]
	sieve[1] = 0
	for i in sieve:
		if i > SN:
			break
		if i == 0:
			continue
		for j in range(2 * i, N + 1, i):
			sieve[j] = 0
	prime = [i for i in range(N + 1) if sieve[i] != 0]
	return prime

def primeFactor(n, prime=getPrimes()):
	lst = []
	mx = int(sqrt(n)) + 1
	for i in prime:
		if i > mx:
			break
		while n % i == 0:
			lst.append(i)
			n //= i
	if n > 1:
		lst.append(n)
	return lst
dx = [-1, 1, 0, 0, 1, -1, 1, -1]
dy = [0, 0, 1, -1, 1, -1, -1, 1]
daysInMounth = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]
import math

def maximumXOR(n, l, r):
	x = 0
	for i in range(31, -1, -1):
		if n & 1 << i:
			if x + (1 << i) - 1 < l:
				x ^= 1 << i
		elif x ^ 1 << i <= r:
			x ^= 1 << i
	return x
num = getInt()
for _ in range(num):
	n = getInt()
	ans1 = 'a' * (n // 2)
	if n % 2 == 0:
		mid = 'b'
	else:
		mid = 'bc'
	print((ans1 + mid + ans1[:-1])[:n])


import sys
from math import *
import builtins
import string
import bisect
alphabets = list(string.ascii_lowercase)
ALPHABETS = list(string.ascii_uppercase)

def print(x, end='\n'):
	sys.stdout.write(str(x) + end)

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
main()


T = int(input())
for _ in range(T):
	n = int(input())
	if n == 1:
		print('a')
	elif n % 2 == 0:
		x = n // 2
		ans = ['a'] * x + ['b'] + ['a'] * (x - 1)
		print(*ans, sep='')
	else:
		x = n // 2
		ans = ['a'] * x + ['b', 'c'] + ['a'] * (x - 1)
		print(*ans, sep='')


T = int(input())
for t in range(T):
	n = int(input())
	x = n // 2
	print('a' * x + 'bc'[:n - x - max(0, x - 1)] + 'a' * max(0, x - 1))


from functools import lru_cache
from collections import deque

def solve():
	t = int(input())
	for _ in range(t):
		n = int(input())
		if n % 2 == 0:
			print('a' * (n // 2) + 'b' + 'a' * ((n - 1) // 2))
		elif n == 1:
			print('a')
		else:
			print('a' * ((n - 1) // 2) + 'bc' + 'a' * ((n - 2) // 2))
solve()


from sys import stdin
input = stdin.buffer.readline

def func():
	if n == 1:
		print('a')
	else:
		s = 'a' * (n // 2)
		if n & 1:
			s += 'bc'
		else:
			s += 'b'
		s += 'a' * (n // 2 - 1)
		print(s)
for _ in range(int(input())):
	n = int(input())
	func()


t = int(input())
while t:
	n = int(input())
	s = ''
	if n == 1:
		print('a')
		t -= 1
		continue
	if n % 2 == 0:
		s += int(n / 2) * 'a' + 'b' + int(n / 2 - 1) * 'a'
	else:
		s += int(n / 2) * 'a' + 'bc' + int(n / 2 - 1) * 'a'
	print(s)
	t -= 1


import sys, os
from math import *
from bisect import *
from heapq import *
from collections import *
if os.path.exists('in.txt'):
	sys.stdin = open('in.txt', 'r')
from io import BytesIO, IOBase

def main():
	for _ in range(int(input())):
		n = int(input())
		k = n // 2
		if n == 1:
			print('a')
		elif n % 2:
			print('a' * k + 'bc' + 'a' * (k - 1))
		else:
			print('a' * k + 'b' + 'a' * (k - 1))
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def MI():
	return map(int, input().split())

def outP(var):
	sys.stdout.write(str(var) + '\n')
MOD = 10 ** 9 + 7
mod = 998244353
main()


import sys
from sys import stdin
tt = int(stdin.readline())
for loop in range(tt):
	n = int(stdin.readline())
	if n == 1:
		print('a')
	elif n % 2 == 0:
		fi = n // 2
		sc = n // 2 - 1
		a = ['a'] * fi
		a.append('b')
		for j in range(sc):
			a.append('a')
		print(''.join(a))
	else:
		fi = n // 2
		sc = n // 2 - 1
		a = ['a'] * fi
		a.append('b')
		a.append('c')
		for j in range(sc):
			a.append('a')
		print(''.join(a))


T = int(input())
for t in range(T):
	n = int(input())
	k = n // 2
	if n == 1:
		print('a')
		continue
	elif n % 2:
		s = 'a' * k + 'bc' + 'a' * (k - 1)
	else:
		s = 'a' * k + 'b' + 'a' * (k - 1)
	print(s)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

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')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from itertools import permutations
from collections import *
from collections import deque
from operator import itemgetter, attrgetter
from decimal import *
import bisect
import math
import heapq as hq
MOD = 10 ** 9 + 7

def is_prime(n):
	if n == 2 or n == 3:
		return True
	if n < 2 or n % 2 == 0:
		return False
	if n < 9:
		return True
	if n % 3 == 0:
		return False
	r = int(n ** 0.5)
	f = 5
	while f <= r:
		if n % f == 0:
			return False
		if n % (f + 2) == 0:
			return False
		f += 6
	return True

def pow(a, b, m):
	ans = 1
	while b:
		if b & 1:
			ans = ans * a % m
		b //= 2
		a = a * a % m
	return ans

def ispalindrome(s):
	if s[:] == s[::-1]:
		return 1
	return 0
dp = []
limit = []
v = []

def dpdfs(u, t=-1):
	dp[0][u] = 0
	dp[1][u] = 0
	for i in v[u]:
		if i == t:
			continue
		if dp[1][i] == -1:
			dpdfs(i, u)
		dp[0][u] += max(abs(limit[0][u] - limit[1][i]) + dp[1][i], abs(limit[0][u] - limit[0][i]) + dp[0][i])
		dp[1][u] += max(abs(limit[1][u] - limit[1][i]) + dp[1][i], abs(limit[1][u] - limit[0][i]) + dp[0][i])
vis = []
f = 0

def dfs(i):
	vis[i] = 1
	act[i] = 1
	for j in v[i]:
		if act[j]:
			f = 1
			return -1
		if vis[j] == 0:
			if dfs(j) == -1:
				return -1
	act[i] = 0
	ans.append(i)
	return 0
from queue import PriorityQueue

def z_algorithm(s):
	res = [0] * len(s)
	res[0] = len(s)
	(i, j) = (1, 0)
	while i < len(s):
		while i + j < len(s) and s[j] == s[i + j]:
			j += 1
		res[i] = j
		if j == 0:
			i += 1
			continue
		k = 1
		while i + k < len(s) and k + res[k] < j:
			res[i + k] = res[k]
			k += 1
		(i, j) = (i + k, j - k)
	return res

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def lcm(a, b):
	return a / gcd(a, b) * b

def gcdExtended(a, b):
	if a == 0:
		return (b, 0, 1)
	(gcd, x1, y1) = gcdExtended(b % a, a)
	x = y1 - b // a * x1
	y = x1
	return (gcd, x, y)
import re
for _ in range(int(input())):
	n = int(input())
	ans = ''
	if n == 1:
		print('a')
		continue
	if n % 2:
		ans += 'a' * (n // 2)
		ans += 'bc'
		ans += 'a' * (n // 2 - 1)
	else:
		ans += 'a' * (n // 2)
		ans += 'b'
		ans += 'a' * (n // 2 - 1)
	print(ans)


from sys import *
input = stdin.readline
from bisect import *
import math
from collections import *
import operator
from heapq import *
from itertools import *
inf = 10 ** 18
mod = 10 ** 9 + 7
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print('a')
		continue
	ans = ''
	if n % 2 == 0:
		n -= 1
		ans += math.ceil(n / 2) * 'a' + 'b' + n // 2 * 'a'
	else:
		n -= 2
		ans += math.ceil(n / 2) * 'a' + 'bc' + n // 2 * 'a'
	print(ans)


t = int(input())
for i in range(t):
	y = ''
	n = int(input())
	if n == 1:
		print('a')
	elif n == 2:
		print('ab')
	else:
		if n % 2 != 0:
			for i in range(n - 1):
				if i == n // 2:
					y = y + 'bc'
				else:
					y = y + 'a'
		else:
			for i in range(n):
				if i == n // 2:
					y = y + 'b'
				else:
					y = y + 'a'
		print(y)


import math

def solve(n):
	n = int(n)
	if n == 1:
		return 'a'
	if n == 2:
		return 'ab'
	if n == 3:
		return 'abc'
	if n % 2 == 0:
		return 'a' * (n // 2) + 'b' + 'a' * (n // 2 - 1)
	else:
		return 'a' * (n // 2) + 'bc' + 'a' * (n // 2 - 1)

def check(s):
	print('checking ' + s)
	for i in range(0, len(s) - 1):
		for j in range(i + 1, len(s)):
			cur = s[i:j]
			c = 0
			for a in range(len(s)):
				if s[a:a + (j - i)] == cur:
					c += 1
			if c % 2 == 0:
				print('even found')
				print(s[i:j])
				print(c)
				return
	print('none found')
import os
import io
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
T = int(input().decode().strip())
for t in range(T):
	n = int(input().decode().strip())
	res = solve(n)
	print(res)


import typing

def solve(n: int) -> typing.NoReturn:
	if n == 1:
		print('a')
		return
	k = n // 2
	mid = 'b'
	if n & 1:
		mid += 'c'
	s = 'a' * k
	s += mid
	s += 'a' * (k - 1)
	print(s)

def main() -> typing.NoReturn:
	t = int(input())
	for _ in range(t):
		n = int(input())
		solve(n)
main()


import bisect
import copy
import decimal
import fractions
import heapq
import itertools
import math
import random
import sys
from collections import Counter, deque, defaultdict
from functools import lru_cache, reduce
from heapq import heappush, heappop, heapify, heappushpop, _heappop_max, _heapify_max

def _heappush_max(heap, item):
	heap.append(item)
	heapq._siftdown_max(heap, 0, len(heap) - 1)

def _heappushpop_max(heap, item):
	if heap and item < heap[0]:
		(item, heap[0]) = (heap[0], item)
		heapq._siftup_max(heap, 0)
	return item
from math import gcd as GCD, modf
read = sys.stdin.read
readline = sys.stdin.readline
readlines = sys.stdin.readlines
t = int(readline())
for _ in range(t):
	N = int(readline())
	if N == 1:
		ans = 'a'
	elif N % 2 == 0:
		ans = 'a' * (N // 2) + 'b' + 'a' * (N // 2 - 1)
	else:
		ans = 'a' * (N // 2) + 'bc' + 'a' * (N // 2 - 1)
	print(ans)


import sys
input = sys.stdin.readline
t = int(input())
while t > 0:
	n = int(input())
	if n == 1:
		s = 'a'
	else:
		s = 'a' * (n // 2)
		if n % 2 != 0:
			s += 'bc'
		else:
			s += 'b'
		s += 'a' * (n // 2 - 1)
	print(s)
	t -= 1


from sys import *
ws = lambda : map(int, stdin.readline().strip().split())
li = lambda : list(map(int, stdin.readline().strip().split()))
mod = 1000000007

def ncr(n, r, p):
	num = den = 1
	for i in range(r):
		num = num * (n - i) % p
		den = den * (i + 1) % p
	return num * pow(den, p - 2, p) % p

def gcd(a, b):
	if b == 0:
		return a
	return gcd(b, a % b)

def prod(l):
	ans = 1
	for i in range(len(l)):
		ans = ans * l[i]
	return ans

def sortindex(l, a):
	c = []
	if a == -1:
		rev = True
	else:
		rev = False
	for i in range(len(l)):
		c.append([l[i], i])
	x = sorted(c, reverse=rev)
	print(x)
	c = []
	for i in range(len(l)):
		c.append(x[i][1])
	return c
for _ in range(int(input())):
	n = int(input())
	if n == 1:
		print('z')
		continue
	if n & 1:
		t1 = n // 2
		t2 = 'a' * t1
		t2 += 'bc'
		t2 += 'a' * (t1 - 1)
		print(t2)
	else:
		t1 = n // 2
		t2 = 'a' * t1
		t2 += 'b'
		t2 += 'a' * (t1 - 1)
		print(t2)