One fall day Joe got bored because he couldn't find himself something interesting to do. Marty suggested Joe to generate a string of length $n$ to entertain him somehow. It didn't seem particularly difficult, but Joe's generated string had to follow these rules:

the string may only contain characters 'a', 'b', or 'c';

the maximum length of a substring of this string that is a palindrome does not exceed $k$.

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. For example, strings "a", "bc", "abc" are substrings of a string "abc", while strings "ac", "ba", "cba" are not.

A string is a palindrome if it reads the same from the left to the right and from the right to the left. For example, strings "abccba", "abbba", "aba", "abacaba", "a", and "bacab" are palindromes, while strings "abcbba", "abb", and "ab" are not.

Now Joe wants to find any correct string. Help him! It can be proven that the answer always exists under the given constraints.


-----Input-----

Each test contains one or more test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10$).

The only line of each test case contains two integers $n$ and $k$ ($1 \le k \le n \le 1000$) — the required string length and the maximum length of a palindrome substring, respectively.


-----Output-----

For each test case, print any string that satisfies the conditions from the problem statement. If there are multiple correct answers, you can print any one of them. It can be proven that the answer always exists under the given constraints.


-----Examples-----

Input
2
3 2
4 1
Output
aab
acba


-----Note-----

In the first test case of the example, the palindrome substring with the maximum length is "aa". Its length does not exceed $2$, so it fits.

In the second test case all palindrome substrings have the length one.

Source: codeforces | Difficulty: EASY
Tags: Greedy algorithms

Constructive algorithms


Solutions:
testcases = int(input())
for testcase in range(testcases):
	temparr = input()
	temparr = temparr.split()
	a = int(temparr[0])
	b = int(temparr[1])
	ans = []
	curentcount = 0
	index = 0
	arr = ['a', 'b', 'c']
	for i in range(a):
		if curentcount == b:
			index += 1
			if index == 3:
				index = 0
			curentcount = 1
			ans.append(arr[index])
		else:
			ans.append(arr[index])
			curentcount += 1
	print(''.join(ans))


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

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

def main():
	(n, k) = cint()
	lst = [0 for i in range(n)]
	for i in range(0, k):
		lst[i] = 'a'
		occ = 0
	for i in range(k, n):
		lst[i] = ['c', 'b', 'a'][occ]
		occ = (occ + 1) % 3
	print(''.join(lst))
t = int(input())
while t != 0:
	main()
	t -= 1


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	s = ''
	for i in range(1, n + 1):
		if i % k != 0:
			s = s + 'a'
		else:
			s = s + 'abc'
	print(s[:n:1])


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	print(('abc' * 334)[:n])


t = int(input())
for _ in range(t):
	(n, k) = [int(x) for x in input().split(' ')]
	ch = 'abc'
	a = 0
	for i in range(0, n, k):
		c = ch[a]
		a += 1
		a %= 3
		for j in range(i, min(n, i + k)):
			print(c, end='')
	print('')


T = int(input())
while T:
	(n, k) = [int(i) for i in input().split()]
	fa = n // 3
	r = n % 3
	output = 'abc' * fa
	if r == 1:
		output = output + 'a'
	if r == 2:
		output = output + 'ab'
	print(output)
	T -= 1


def answer():
	return 'a' * k + 'bca' * ((n - k) // 3) + 'bca'[:(n - k) % 3]
for T in range(int(input())):
	(n, k) = map(int, input().split())
	print(answer())


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	s = 'abc' * (n // 3)
	if n % 3 == 1:
		s += 'a'
	elif n % 3 == 2:
		s += 'ab'
	print(s)


t = int(input())
while t > 0:
	t -= 1
	(n, k) = (int(_) for _ in input().strip().split(' '))
	c = []
	for i in range(1, n + 1):
		if i % 3 == 1:
			c.append('a')
		if i % 3 == 2:
			c.append('b')
		if i % 3 == 0:
			c.append('c')
	for i in c[:-1]:
		print(i, end='')
	print(c[-1])


def process(n, k):
	string = 'a' * k + 'b' * k + 'c' * k
	string = string * n
	string = string[0:n]
	return string
t = int(input())
for i in range(t):
	inp = input().split()
	print(process(int(inp[0]), int(inp[1])))


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	for i in range(n):
		if i % 3 == 0:
			print('a', end='')
		elif i % 3 == 1:
			print('b', end='')
		else:
			print('c', end='')
	print('')


T = int(input())
while T:
	(n, k) = map(int, input().split(' '))
	string = ''
	(q, r) = divmod(n, 3)
	string += 'abc' * q
	if r != 0:
		if r == 1:
			string += 'a'
		elif r == 2:
			string += 'ab'
	print(string)
	T -= 1


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	A = [''] * n
	s = 'abc'
	for i in range(n):
		print(s[i % 3], end='')
	print()


t = int(input())
for _ in range(t):
	(n, k) = [int(i) for i in input().split()]
	a = n // 3
	ans = 'abc' * a
	b = n - 3 * a
	if b > 0:
		ans += 'a'
	if b > 1:
		ans += 'b'
	print(ans)


from sys import stdout, stdin
from collections import defaultdict, deque
t = int(stdin.readline())
for _ in range(t):
	(n, k) = map(int, stdin.readline().split())
	s = ''
	for i in range(k):
		s += 'a'
	te = 'bca'
	z = (n - k) // 3
	r = (n - k) % 3
	for i in range(z):
		s += te
	if r > 0:
		s += te[:r]
	print(s)


t = int(input())
for _ in range(t):
	(n, k) = [int(a) for a in input().split()]
	print('abc' * (n // 3) + 'abc'[:n % 3])


from math import *
from bisect import *
from collections import *
from random import *
from decimal import *
import sys
input = sys.stdin.readline

def inp():
	return int(input())

def st():
	return input().rstrip('\n')

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

def ma():
	return map(int, input().split())
t = inp()
while t:
	t -= 1
	(n, k) = ma()
	po = 0
	s = 'a' * k + 'b' * k + 'c' * k
	need = n // (3 * k) * s
	re = n % (3 * k)
	need += s[:re]
	print(need)


t = int(input())
for c in range(t):
	(n, k) = input().split(' ')
	n = int(n)
	s = ''
	i = 1
	while i <= n:
		if i % 3 == 1:
			s = s + 'a'
		elif i % 3 == 2:
			s = s + 'b'
		else:
			s = s + 'c'
		i = i + 1
	print(s)


no_of_test_case = int(input())
l = ['a', 'b', 'c']
flag = 0
while no_of_test_case != 0:
	(n, k) = map(int, input().split())
	string = ''
	if k == 1:
		for i in range(0, n):
			if flag > 2:
				flag = 0
			string += l[flag]
			flag += 1
	else:
		for i in range(0, k):
			string += l[flag]
		flag += 1
		for i in range(0, n - k):
			if flag > 2:
				flag = 0
			string += l[flag]
			flag += 1
	print(string)
	flag = 0
	no_of_test_case -= 1


for i in range(int(input())):
	(n, k) = map(int, input().split())
	res = 'a' * k
	if n == 3 and k == 2:
		print('aab')
		continue
	d = n - k
	if d % 3 == 0:
		res = res + 'bca' * (d // 3)
	elif d % 3 == 2:
		res = res + 'bca' * (d // 3) + 'bc'
	else:
		res = res + 'bca' * (d // 3) + 'b'
	print(res)


for _ in range(int(input())):
	(n, k) = list(map(int, input().split()))
	s = ['a' for i in range(n)]
	for i in range(k, n):
		s[i] = chr(97 + (i - k + 1) % 3)
	print(''.join(s))


import sys, io, os, math

def printlist(n):
	sys.stdout.write(' '.join(map(str, n)) + '\n')

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

def printns(n):
	sys.stdout.write(str(n))

def intinp():
	return int(sys.stdin.readline())

def strinp():
	return sys.stdin.readline()

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

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

def flush():
	return stdout.flush()

def solve():
	(n, k) = multiinp()
	s = 'abc'
	count = 0
	for i in range(0, n):
		print(s[count], end='')
		count = (count + 1) % 3
	print()

def main():
	tc = intinp()
	for _ in range(0, tc):
		solve()
main()


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	ans = ''
	while len(ans) < n:
		ans += 'a'
		if len(ans) < n:
			ans += 'b'
		else:
			break
		if len(ans) < n:
			ans += 'c'
	print(ans)


t1 = int(input())
for _ in range(t1):
	(n, k) = map(int, input().split())
	b = 'abc' * n
	if len(b) > n:
		b = b[:n]
		print(b)
	else:
		print(b)


import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
from collections import Counter
from collections import defaultdict as dd
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
stdmap = lambda : map(int, stdstr().split())
stdarr = lambda : list(map(int, stdstr().split()))
mod = 1000000007
for _ in range(stdint()):
	(n, k) = stdmap()
	l = ['a', 'b', 'c']
	p = 0
	res = []
	curr = 0
	for i in range(n):
		if curr == k:
			p = (p + 1) % 3
			curr = 0
		res.append(l[p])
		curr += 1
	print(''.join(res))


q = int(input())
for _ in range(q):
	(n, k) = map(int, input().split())
	s = 'bca'
	t = ''
	t += 'a' * k
	n = n - k
	if n % 3 == 0:
		t += s * (n // 3)
	else:
		p = n % 3
		t += s * (n // 3)
		if p == 1:
			t += 'b'
		elif p == 2:
			t += 'bc'
	print(t)


tc = int(input())
for t in range(tc):
	(n, k) = map(int, input().strip().split())
	ans = ''
	for i in range(k):
		ans += 'a'
	while len(ans) < n - 3:
		ans += 'bca'
	if len(ans) == n - 3:
		ans += 'bca'
	elif len(ans) == n - 2:
		ans += 'bc'
	elif len(ans) == n - 1:
		ans += 'b'
	print(ans)


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	s = 'abc' * ((n - k + 1) // 3)
	x = (n - k + 1) % 3
	li = 'abc'
	s += li[:x]
	s = 'a' * (k - 1) + s
	print(s)


def string(n):
	s = ''
	s += n // 3 * 'abc'
	if n % 3 == 1:
		s += 'a'
	elif n % 3 == 2:
		s += 'ab'
	return s
t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	print(string(n))


for u in range(int(input())):
	(n, k) = map(int, input().split())
	t = n - k
	s = ''
	for i in range(t):
		if i % 3 == 0:
			s += 'a'
		if i % 3 == 1:
			s += 'b'
		if i % 3 == 2:
			s += 'c'
	if t % 3 == 0:
		s += 'a' * k
	if t % 3 == 1:
		s += 'b' * k
	if t % 3 == 2:
		s += 'c' * k
	print(s)


import sys
import math
import collections
import operator as op
from collections import deque
from math import gcd, inf, sqrt, pi, cos, sin, ceil, log2, floor, log
from bisect import bisect_right, bisect_left, bisect
from functools import reduce
from sys import stdin, stdout, setrecursionlimit
setrecursionlimit(2 ** 20)

def ncr(n, r):
	r = min(r, n - r)
	numer = reduce(op.mul, range(n, n - r, -1), 1)
	denom = reduce(op.mul, range(1, r + 1), 1)
	return numer // denom

def prime_factors(n):
	i = 2
	factors = []
	while i * i <= n:
		if n % i:
			i += 1
		else:
			n //= i
			factors.append(i)
	if n > 1:
		factors.append(n)
	return list(factors)

def isPowerOfTwo(x):
	return x and (not x & x - 1)
MOD = 1000000007
PMOD = 998244353
N = 10 ** 6
LOGN = 30
alp = 'abcdefghijklmnopqrstuvwxyz'
T = 1
T = int(stdin.readline())
for _ in range(T):
	(n, k) = list(map(int, stdin.readline().rstrip().split()))
	n -= k
	s = 'a' * k
	for i in range(n):
		if i % 3 == 0:
			s += 'c'
		elif i % 3 == 1:
			s += 'b'
		else:
			s += 'a'
	print(s)


def solve(n, k):
	s = ['a', 'c', 'b']
	ans = 'a'
	ans = ans * k
	j = 0
	c = 1
	while j < n - k:
		if c > 2:
			c = 0
		ans += s[c]
		j += 1
		c += 1
	return ans
T = int(input())
for t in range(T):
	nk = input().split()
	n = int(nk[0])
	k = int(nk[1])
	print(solve(n, k))


t = int(input())
for _ in range(t):
	(n, k) = (int(i) for i in input().split())
	res = ('abc' * ((n + 2) // 3))[:n]
	print(res)


t = int(input())
for i in range(t):
	(k, n) = list(map(int, input().split()))
	s = 'abc' * (k // 3)
	if len(s) < k:
		s = s + 'a'
	if len(s) < k:
		s = s + 'b'
	print(s)


import math
T = int(input())
while T > 0:
	T -= 1
	ans = ''
	(n, y) = map(int, input().split())
	for i in range(n // 3):
		ans += 'abc'
	if n % 3 == 1:
		ans += 'a'
	elif n % 3 == 2:
		ans += 'ab'
	print(ans)


sad = 'abc' * 2021
for i in range(int(input())):
	(x, y) = list(map(int, input().split()))
	print(sad[:x])


import math
from sys import stdin
from heapq import *
from itertools import permutations
from collections import Counter, OrderedDict, deque
inp = lambda : stdin.readline().strip()
ii = lambda : int(inp())
si = lambda : map(int, inp().split())
sf = lambda : map(float, inp().split())
li = lambda : list(si())
lf = lambda : list(sf())
lin = lambda : list(inp())
liin = lambda : [int(c) for c in inp()]
infy = float('inf')
mod = int(1000000000.0) + 7
test = ii()
for _ in range(test):
	(n, k) = si()
	v = ['a', 'b', 'c']
	ans = ''
	for i in range(n):
		ans += v[i % 3]
	print(ans)


for _ in range(int(input())):
	(n, k) = list(map(int, input().split()))
	s = ['a', 'b', 'c']
	l = []
	for i in range(n):
		l.append(s[i % 3])
	print(''.join(l))


try:
	import math
	for _ in range(int(input())):
		(n, k) = map(int, input().split())
		s = 'a' * k
		i = k
		while i < n:
			if s[-1] == 'a':
				s = s + 'b'
			elif s[-1] == 'b':
				s = s + 'c'
			else:
				s = s + 'a'
			i += 1
		print(s)
except:
	pass


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	t = 'a' * k
	n -= k
	s = n // 3
	r = n % 3
	st = 'bca'
	t += st * s
	t += st[:r]
	print(t)


for t in range(int(input())):
	(a, b) = list(map(int, input().split()))
	k = ['a', 'b', 'c']
	s = []
	for i in range(a):
		s.append(k[i % 3])
	print(''.join(s))


import os
import sys
from io import BytesIO, IOBase
import math
from collections import defaultdict, deque
import random
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')
for _ in range(int(input())):
	(s, k) = map(int, input().split(' '))
	ans = 'abc' * (s // 3) + 'abc'[:s % 3]
	print(ans)


for t in range(int(input())):
	(n, k) = map(int, input().split(' '))
	print(('abc' * n)[:n])


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	s1 = 'a' * k
	x = 0
	y = 0
	z = 0
	while len(s1) != n:
		if x == 0:
			s1 += 'c'
			x = 1
			y = 0
		elif y == 0:
			s1 += 'b'
			y = 1
			z = 0
		elif z == 0:
			s1 += 'a'
			z = 1
			x = 0
	print(s1)


t = int(input())
import math
for i in range(0, t):
	nm = input().split()
	n = int(nm[0])
	k = int(nm[1])
	k_1 = 3 * k
	x = math.ceil(n / k_1)
	string = ''
	output_string = ''
	out_1 = ''
	for i in range(0, k):
		string = string + 'a'
	for i in range(k, 2 * k):
		string = string + 'b'
	for i in range(2 * k, 3 * k):
		string = string + 'c'
	for i in range(0, x):
		output_string += string
	out_1 = output_string[:n]
	print(out_1)


for i in range(int(input())):
	(x, y) = map(int, input().split(' '))
	p = 'a' * y
	s = ['a', 'b', 'c']
	print(p, end='')
	c = 0
	for i in range(x - y):
		c += 1
		if c > 2:
			c = 0
		print(s[c], end='')
	print()


def main():
	for i in range(int(input())):
		(n, k) = input().split()
		n = int(n)
		k = int(k)
		string: list[str] = []
		for x in range(n):
			if x % 3 == 0:
				string.append('a')
			elif (x - 1) % 3 == 0:
				string.append('b')
			else:
				string.append('c')
		print(''.join(string))
main()


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	print(''.join([chr(ord('a') + i % 3) for i in range(n)]))


import math, sys
from collections import defaultdict, deque
import bisect as bi

def yes():
	print('YES')

def no():
	print('NO')

def I():
	return int(sys.stdin.readline())

def In():
	return map(int, sys.stdin.readline().split())

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

def dict(a):
	d = {}
	for x in a:
		if d.get(x, -1) != -1:
			d[x] += 1
		else:
			d[x] = 1
	return d

def find_gt(a, x):
	i = bi.bisect_left(a, x)
	if i != len(a):
		return i
	else:
		return -1

def main():
	try:
		(n, k) = In()
		z = 'abc'
		ans = []
		for i in range(n // 3):
			ans.append(z)
		if n % 3 == 1:
			ans.append('a')
		elif n % 3 == 2:
			ans.append('ab')
		print(''.join(ans))
	except:
		pass
M = 998244353
P = 1000000007
for _ in range(I()):
	main()


t = int(input())
for z in range(t):
	(n, n1) = map(int, input().split())
	d = []
	d.append('a')
	for i in range(n):
		if d[i] == 'a':
			d.append('b')
		elif d[i] == 'b':
			d.append('c')
		elif d[i] == 'c':
			d.append('a')
	for i in range(n):
		print(d[i], end='')
	print()


from collections import deque
test = int(input())
for _ in range(test):
	(n, k) = map(int, input().split())
	arr = ['a', 'b', 'c']
	i = 0
	cnt = 0
	s = ''
	while cnt < n:
		s += arr[i]
		i = (i + 1) % 3
		cnt += 1
	print(s)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	s = 'abc' * 350
	print(s[:n])


t = int(input())
while t != 0:
	(n, k) = list(map(int, input().split()))
	a = k * 'a'
	if (n - k) % 3 == 0:
		a = a + (n - k) // 3 * 'cba'
	else:
		a = a + (n - k) // 3 * 'cba'
		if (n - k) % 3 == 1:
			a = a + 'c'
		else:
			a = a + 'cb'
	print(a)
	t -= 1


import sys, io, os, time
from collections import defaultdict
from collections import Counter
from collections import deque
from itertools import combinations
from itertools import permutations
import bisect, math, heapq
alphabet = 'abcdefghijklmnopqrstuvwxyz'
input = sys.stdin.readline
for ii in range(int(input())):
	(n, k) = map(int, input().split())
	i = 0
	arr = ['a', 'b', 'c']
	ans = ''
	for j in range(n):
		ans += arr[i]
		i += 1
		i %= 3
	print(ans)


def convert(lis):
	for i in range(len(lis)):
		lis[i] = int(lis[i])
	return lis
t = int(input())
for i in range(t):
	string = ''
	string1 = ['a', 'b', 'c']
	params = convert(input().split())
	if params[1] == 0:
		print('NO')
	elif params[1] >= 1:
		count = 0
		for j in range(params[1] - 1):
			string += 'a'
			count += 1
		if params[1] - count > 0:
			index = 0
			for z in range(params[0] - count):
				if index == 3:
					index = 0
					string += string1[index]
					index += 1
					continue
				string += string1[index]
				index += 1
	print(string)


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	s = 'abc' * (n // 3) + 'abc'[:n % 3]
	print(s)


a = ['a', 'b', 'c']
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	res = []
	for i in range(n):
		res.append(a[i % 3])
	print(''.join(res))


tests = int(input())
result = list(range(tests))
for i in range(tests):
	(n, k) = map(int, input().split())
	a = 'abc' * 1010
	print(a[:n])


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	tpl = 'abc'
	for i in range(n):
		print(tpl[i % 3], end='')
	print()


import math
from collections import deque
from sys import stdin, stdout, setrecursionlimit
from string import ascii_letters
from decimal import *
letters = ascii_letters[:26]
from collections import defaultdict
input = stdin.readline
print = stdout.write
for _ in range(int(input())):
	(a, b) = map(int, input().split())
	val = ['a', 'b', 'c']
	for i in range(a):
		print(val[i % 3])
	print('\n')


t = int(input())
for items in range(t):
	sr = ''
	(n, k) = map(int, input().split())
	sr += 'a' * k
	sr += 'bca' * (n - k)
	print(sr[:n])


for _ in range(int(input())):
	(a, b) = map(int, input().split())
	c = a - b
	k = ''
	if c % 3 == 1:
		k = 'b'
	if c % 3 == 2:
		k = 'bc'
	s = 'a' * b + c // 3 * 'bca' + k
	print(s)


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	ans = ''
	for i in range(k):
		ans += 'a'
	t = ['b', 'c', 'a'] * (n - k)
	t = ''.join(t)
	ans = ans + t[:n - k]
	print(ans)


from sys import stdin, stdout
from math import factorial as f
from math import gcd
from random import randint, shuffle
input = stdin.readline
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	print('abc' * (n // 3) + 'abc'[:n % 3])


for _ in range(int(input())):
	(n, k) = map(int, input().strip().split())
	s = []
	c = 0
	while k:
		k -= 1
		s.append('a')
		c += 1
	j = 1
	for i in range(c, n):
		if j == 1:
			s.append('c')
			j = 2
		elif j == 2:
			s.append('b')
			j = 3
		else:
			s.append('a')
			j = 1
	print(''.join(s))


import sys
input = sys.stdin.readline

def solve():
	(n, k) = map(int, input().split())
	return ('abc' * (n // 3 + 1))[:n]
for _ in range(int(input())):
	print(solve())


import sys

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

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

def input():
	return sys.stdin.readline().strip()
for _ in range(int(input())):
	(n, k) = get_ints()
	ans = n // 3
	rem = n % 3
	str = 'abc' * ans
	if rem == 1:
		str += 'a'
	if rem == 2:
		str += 'ab'
	print(str)


from __future__ import division, print_function
import os
import sys
from io import BytesIO, IOBase
DEBUG_MODE = False

def debug(*args, **kwargs):
	if DEBUG_MODE:
		print(*args, **kwargs)

def main():
	T = iin()
	while T:
		T -= 1
		(n, k) = lin()
		ans = 'abc' * 1000
		print(ans[:n])
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')

def iin():
	return int(input())

def lin():
	return list(map(int, input().split()))
if DEBUG_MODE:
	import cProfile
	cProfile.run('main()')
else:
	main()


for _ in range(int(input())):
	(n, k) = list(map(int, input().split()))
	s = 'abc'
	z = n % 3
	x = n // 3
	a = s * x + s[:z]
	print(a)


import sys
alph = ['a', 'b', 'c']
n = int(input())
for i in range(n):
	st = ''
	(x, y) = map(int, input().split())
	for i in range(x):
		st += alph[(y + i) % len(alph)]
	print(st)


t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	s = ''
	for i in range(n):
		if i < k:
			s = s + 'a'
	i = 1
	d = n - k
	while i < d + 1:
		if i % 3 == 1:
			s = s + 'b'
		elif i % 3 == 2:
			s = s + 'c'
		elif i % 3 == 0:
			s = s + 'a'
		i = i + 1
	print(s)


t = int(input())
for i in range(0, t):
	(n, k) = map(int, input().split())
	ans = ''
	j = n // 3
	remainder = n % 3
	for k in range(0, j):
		ans += 'abc'
	if remainder != 0:
		ans += 'a'
		remainder -= 1
	if remainder != 0:
		ans += 'b'
	print(ans)


def d(m):
	i = 0
	re = []
	while i < m[0]:
		print(chr(ord('a') + i % 3), end='')
		i += 1
	print()
n = input()
for i in range(int(n)):
	m = list(map(int, input().split()))
	d(m)


t = int(input())
i = 1
while i <= t:
	[n, k] = list(map(int, input().split()))
	res = ''
	j = 1
	while j <= k:
		res += 'a'
		j += 1
	j = 1
	while j <= n - k:
		if j % 3 == 1:
			res += 'b'
		elif j % 3 == 2:
			res += 'c'
		else:
			res += 'a'
		j += 1
	print(res)
	i += 1


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	ans = 'abc' * n
	for i in range(n):
		print(ans[i], end='')
	print()


t = int(input())
for i in range(t):
	s = ''
	(n, k) = map(int, input().split())
	for j in range(n):
		s += chr(ord('a') + j % 3)
	print(s)


from collections import Counter
import string
import math
import sys
from fractions import Fraction
from itertools import product

def array_int():
	return [int(i) for i in sys.stdin.readline().split()]

def vary(arrber_of_variables):
	if arrber_of_variables == 1:
		return int(sys.stdin.readline())
	if arrber_of_variables >= 2:
		return map(int, sys.stdin.readline().split())

def makedict(var):
	return dict(Counter(var))

def printDivisors(n):
	divisors = []
	i = 1
	while i <= math.sqrt(n):
		if n % i == 0:
			if n // i == i:
				divisors.append(i)
			else:
				divisors.extend((i, n // i))
		i = i + 1
	return divisors

def countTotalBits(num):
	binary = bin(num)[2:]
	return len(binary)

def isPrime(n):
	if n <= 1:
		return False
	if n <= 3:
		return True
	if n % 2 == 0 or n % 3 == 0:
		return False
	i = 5
	while i * i <= n:
		if n % i == 0 or n % (i + 2) == 0:
			return False
		i = i + 6
	return True
mod = 10 ** 9 + 7

def comp(x):
	return x[1]

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

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

def primeFactors(n):
	factors = []
	while n % 2 == 0:
		factors.append(2)
		n = n // 2
	for i in range(3, int(math.sqrt(n)) + 1, 2):
		while n % i == 0:
			factors.append(i)
			n = n // i
	if n > 2:
		factors.append(n)
	return factors
mod = 10 ** 9 + 7
testCases = 1
testCases = vary(1)
for _ in range(testCases):
	(n, k) = vary(2)
	s = 'abc'
	i = 0
	while n > 0:
		if i == 3:
			i = 0
		print(s[i], end='')
		n -= 1
		i += 1
	print()


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	ss = 'a' * k
	n = n - k
	for i in range(n):
		if i % 3 == 0:
			ss += 'b'
		if i % 3 == 1:
			ss += 'c'
		if i % 3 == 2:
			ss += 'a'
	print(ss)


import os
import sys
from io import BytesIO, IOBase
input = sys.stdin.readline

def inp():
	return int(input())

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

def insr():
	s = input()
	return list(s[:len(s) - 1])

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

def main():
	try:
		for _ in range(inp()):
			(n, k) = invr()
			ans = 'abc' * (n // 3)
			if n % 3 == 1:
				ans = ans + 'a'
			elif n % 3 == 2:
				ans = ans + 'ab'
			print(ans)
	except Exception as e:
		print(e)
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')
main()


for i in range(int(input())):
	(n, k) = map(int, input().split())
	s = 'abc' * n
	print(s[0:n])


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	c = ''
	for i in range(k):
		c += 'a'
		n -= 1
	if n - k >= 1:
		c += 'b'
		n -= 1
	for i in range(n // 3):
		c += 'cab'
	if n % 3 == 1:
		c += 'c'
	elif n % 3 == 2:
		c += 'ca'
	print(c)


t = int(input())
for k in range(t):
	(n, k) = list(map(int, input().split()))
	s = ''
	for i in range(n):
		s += 'abc'[i % 3]
	print(s)


t = int(input())
while t:
	(n, m) = map(int, input().split())
	q = 0
	while n:
		if q == 0:
			print('a', end='')
			q = 1
		elif q == 1:
			print('b', end='')
			q = 2
		else:
			print('c', end='')
			q = 0
		n -= 1
	print()
	t -= 1


letters = ['a', 'b', 'c']
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	for i in range(n):
		print(letters[i % 3], end='')
	print()


for s in [*open(0)][1:]:
	n = int(s.split()[0])
	print(('abc' * n)[:n])


from sys import stdin
input = stdin.readline
t = int(input())
for i in range(t):
	(n, k) = map(int, input().split())
	s = (k - 1) * 'a' + (n - k + 1) // 3 * 'abc'
	if (n - k + 1) % 3 == 0:
		print(s)
	elif (n - k + 1) % 3 == 1:
		print(s + 'a')
	elif (n - k + 1) % 3 == 2:
		print(s + 'ab')


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	print((k - 1) * 'a' + ('abc' * n)[:n - k + 1])


t = int(input())
for q in range(t):
	(n, k) = map(int, input().split())
	x = 3 * k
	y = n // x
	answer = 'a' * k + 'b' * k + 'c' * k
	answer = answer * y
	if n % x <= k - 1:
		answer = answer + 'a' * (n % x)
	elif n % x <= 2 * k:
		answer = answer + 'a' * k + 'b' * (n % x - k)
	else:
		answer = answer + 'a' * k + 'b' * k + 'c' * (n % x - 2 * k)
	print(answer)


letter = ['b', 'c', 'a']
for _ in range(int(input())):
	(n, k) = map(int, input().split())
	result = 'a' * k
	for i in range(k, n):
		result = result + letter[(i - k) % 3]
	print(result)


t = int(input())
for j in range(t):
	(n, k) = list(map(int, input().split()))
	L = ['a', 'b', 'c']
	s = []
	s.append('a' * k)
	s.append('cba' * ((n - k) // 3))
	if (n - k) % 3 == 1:
		s.append('c')
	elif (n - k) % 3 == 2:
		s.append('cb')
	print(''.join(s))


import sys
rl = lambda : list(map(int, sys.stdin.readline().split()))
for _ in range(int(input())):
	(n, k) = rl()
	s = 'abc' * n
	print(s[:n])


sad = 'abc' * 2021
for i in range(int(input())):
	print(sad[:list(map(int, input().split()))[0]])


t = int(input())
for x in range(t):
	(a, b) = input().split()
	n = int(a)
	s = ''
	for i in range(n):
		if i % 3 == 0:
			s += 'a'
		if i % 3 == 1:
			s += 'b'
		if i % 3 == 2:
			s += 'c'
	print(s)


for i in range(int(input())):
	arr = [int(_) for _ in input().split()]
	l = []
	for j in range(arr[0] // 3):
		l.append('a')
		l.append('b')
		l.append('c')
	if arr[0] % 3 == 1:
		l.append('a')
	elif arr[0] % 3 == 2:
		l.append('a')
		l.append('b')
	print(''.join(l))


t = int(input())
for _ in range(t):
	s = 'abc' * 355
	(n, k) = map(int, input().split())
	print(s[:n])


def read_int():
	return int(input())

def read_ints():
	return map(int, input().split(' '))
t = read_int()
for case_num in range(t):
	(n, k) = read_ints()
	print(('abc' * n)[:n])


t = int(input())
while t > 0:
	(n, k) = [int(x) for x in input().split()]
	name = 'abc'
	for i in range(0, n):
		print(name[i % 3], end='')
	print('')
	t -= 1


for i in range(int(input())):
	(n, k) = map(int, input().split())
	if n % 3 == 0:
		for j in range(n // 3):
			print('abc', end='')
		print()
	elif n % 3 != 0:
		for j in range(n // 3):
			print('abc', end='')
		if n % 3 == 1:
			print('a')
		else:
			print('ab')


test_cases = input()
character_array = ['a', 'b', 'c']
input_array = []
for i in range(int(test_cases)):
	input_array.append(list(map(int, input().split(' '))))
for i in input_array:
	output_string = ''
	for j in range(i[0]):
		output_string += character_array[j % 3]
	print(output_string)


i = input()
for _ in range(int(i)):
	(n, k) = map(int, input().split())
	div = n // 3
	rem = n % 3
	res = []
	while div > 0:
		res.append('abc')
		div -= 1
	if rem == 1:
		res.append('a')
	if rem == 2:
		res.append('ab')
	print(''.join(res))


t = int(input())
for i in range(t):
	(x, y) = input().split()
	for i in range(int(x)):
		if i % 3 == 0:
			print('a', end='')
		if i % 3 == 1:
			print('b', end='')
		if i % 3 == 2:
			print('c', end='')
	print()


N = int(input())
ans = [0] * N
for i in range(N):
	ans[i] = [0] * 1000
for i in range(N):
	(a, b) = map(int, input().split())
	k = 0
	s = 'a'
	while k != a:
		ans[i][k] = s
		k += 1
		if k % b == 0:
			if s == 'a':
				s = 'b'
			elif s == 'b':
				s = 'c'
			else:
				s = 'a'
for i in range(N):
	for j in range(len(ans[i])):
		if ans[i][j] != 0:
			print(ans[i][j], end='')
	print()


import os
import sys
from io import BytesIO, IOBase

def main():
	test = int(input())
	for _ in range(test):
		st = 'abc'
		(m, n) = map(int, input().split())
		st *= m
		p = st[:m]
		if n == 1:
			print(p)
		elif n == m:
			ps = 'a' * m
			print(ps)
		else:
			k = 'a' * n
			p = list(p)
			remain = 'cba' * m
			k += remain[:m - n]
			print(k)
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')
main()


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	(full, partial) = (n // 3, n % 3)
	answer = 'abc' * full + 'abc'[:partial]
	print(answer)


def get_next(sym):
	if sym == 'a':
		return 'b'
	elif sym == 'b':
		return 'c'
	else:
		return 'a'

def get_str(length, sub_length):
	s = ''
	prev_sym = 'a'
	cur_sub_len = 0
	for i in range(length):
		if cur_sub_len + 1 <= sub_length:
			s += prev_sym
			cur_sub_len += 1
		else:
			prev_sym = get_next(prev_sym)
			s += prev_sym
			cur_sub_len = 1
	return s
n = input()
input_list = []
for i in range(int(n)):
	(length, sub_length) = input().split(' ')
	input_list.append((int(length), int(sub_length)))
for i in range(int(n)):
	print(get_str(input_list[i][0], input_list[i][1]))


for _ in range(int(input())):
	(n, k) = [int(x) for x in input().split()]
	print('abc' * (n // 3) + 'abc'[:n % 3])


for _ in range(int(input())):
	(n, k) = map(int, input().split())
	s = k * 'a'
	while len(s) < n:
		s += 'bc' + k * 'a'
	print(s[:n])


t = int(input())
for i in range(t):
	temp = [int(x) for x in input().split()]
	n = temp[0]
	k = temp[1]
	result = k * 'a'
	while len(result) != n:
		if len(result) == n:
			break
		else:
			result += 'c'
		if len(result) == n:
			break
		else:
			result += 'b'
		if len(result) == n:
			break
		else:
			result += 'a'
	print(result)


from __future__ import division, print_function
import os, sys
from io import BytesIO, IOBase
if sys.version_info[0] < 3:
	from __builtin__ import xrange as range
	from future_builtins import ascii, filter, hex, map, oct, zip

def ii():
	return int(input())

def fi():
	return float(input())

def si():
	return input()

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

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

def li():
	return list(mi())

def read():
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')

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

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

def modInverse(b, m):
	g = gcd(b, m)
	if g != 1:
		return -1
	else:
		return pow(b, m - 2, m)

def modu(a, b, m):
	a = a % m
	inv = modInverse(b, m)
	if inv == -1:
		return -999999999
	else:
		return inv * a % m
from math import log, sqrt, factorial, cos, tan, sin, radians, floor, ceil, log2
import bisect
from decimal import *
getcontext().prec = 8
abc = 'abcdefghijklmnopqrstuvwxyz'
pi = 3.141592653589793

def main():
	for _ in range(ii()):
		(n, k) = mi()
		s = 'abc'
		r = n % 3
		q = n // 3
		ans = s * q + s[0:r]
		print(ans)
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')

def print(*args, **kwargs):
	(sep, file) = (kwargs.pop('sep', ' '), kwargs.pop('file', sys.stdout))
	at_start = True
	for x in args:
		if not at_start:
			file.write(sep)
		file.write(str(x))
		at_start = False
	file.write(kwargs.pop('end', '\n'))
	if kwargs.pop('flush', False):
		file.flush()
if sys.version_info[0] < 3:
	(sys.stdin, sys.stdout) = (FastIO(sys.stdin), FastIO(sys.stdout))
else:
	(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


t = int(input())
for _ in range(t):
	(n, k) = list(map(int, input().strip().split()))
	a = n // 3
	b = n % 3
	ans = ''
	for i in range(a):
		ans += 'abc'
	if b == 2:
		ans += 'ab'
	elif b == 1:
		ans += 'a'
	print(ans)


t = int(input())

def solve():
	(n, k) = map(int, input().split())
	ans = []
	i = 0
	done = False
	while True:
		if done:
			break
		for c in 'abc':
			ans.append(c)
			i += 1
			if i == n:
				done = True
				break
	print(''.join(ans))
for i in range(t):
	solve()


t = int(input())
for _ in range(t):
	(n, k) = map(int, input().split())
	for i in range(n):
		print(chr(ord('a') + i % 3), end='')
	print()


import sys

def string(m):
	possible = ''
	for i in range(int(m)):
		if i % 3 == 0:
			possible = possible + 'a'
		elif i % 3 == 1:
			possible = possible + 'b'
		else:
			possible = possible + 'c'
	return possible
input = sys.stdin.read()
a = list(map(int, input.split()))
n = a[0]
for i in range(n):
	m = a[2 * i + 1]
	print(string(m))


from sys import stdin
t = int(stdin.readline())
for _ in range(t):
	(n, k) = map(int, stdin.readline().split())
	for i in range(n):
		print(chr(ord('a') + i % 3), end='')
	print()


t = int(input())
for i in range(t):
	[n, x] = list(map(int, input().split(' ')))
	string = 'a'
	for i in range(2, n + 1):
		if i % 3 == 1:
			string += 'a'
		elif i % 3 == 2:
			string += 'b'
		elif i % 3 == 0:
			string += 'c'
	print(string)