The length of the longest common prefix of two strings $s = s_1 s_2 \ldots s_n$ and $t = t_1 t_2 \ldots t_m$ is defined as the maximum integer $k$ ($0 \le k \le min(n,m)$) such that $s_1 s_2 \ldots s_k$ equals $t_1 t_2 \ldots t_k$.

Koa the Koala initially has $n+1$ strings $s_1, s_2, \dots, s_{n+1}$.

For each $i$ ($1 \le i \le n$) she calculated $a_i$ — the length of the longest common prefix of $s_i$ and $s_{i+1}$.

Several days later Koa found these numbers, but she couldn't remember the strings.

So Koa would like to find some strings $s_1, s_2, \dots, s_{n+1}$ which would have generated numbers $a_1, a_2, \dots, a_n$. Can you help her?

If there are many answers print any. We can show that answer always exists for the given constraints. 


-----Input-----

Each test contains multiple test cases. The first line contains $t$ ($1 \le t \le 100$) — the number of test cases. Description of the test cases follows.

The first line of each test case contains a single integer $n$ ($1 \le n \le 100$) — the number of elements in the list $a$.

The second line of each test case contains $n$ integers $a_1, a_2, \ldots, a_n$ ($0 \le a_i \le 50$) — the elements of $a$.

It is guaranteed that the sum of $n$ over all test cases does not exceed $100$.


-----Output-----

For each test case:

Output $n+1$ lines. In the $i$-th line print string $s_i$ ($1 \le |s_i| \le 200$), consisting of lowercase Latin letters. Length of the longest common prefix of strings $s_i$ and $s_{i+1}$ has to be equal to $a_i$.

If there are many answers print any. We can show that answer always exists for the given constraints.


-----Example-----
Input
4
4
1 2 4 2
2
5 3
3
1 3 1
3
0 0 0

Output
aeren
ari
arousal
around
ari
monogon
monogamy
monthly
kevinvu
kuroni
kurioni
korone
anton
loves
adhoc
problems


-----Note-----

In the $1$-st test case one of the possible answers is $s = [aeren, ari, arousal, around, ari]$.

Lengths of longest common prefixes are:  Between $\color{red}{a}eren$ and $\color{red}{a}ri$ $\rightarrow 1$  Between $\color{red}{ar}i$ and $\color{red}{ar}ousal$ $\rightarrow 2$  Between $\color{red}{arou}sal$ and $\color{red}{arou}nd$ $\rightarrow 4$  Between $\color{red}{ar}ound$ and $\color{red}{ar}i$ $\rightarrow 2$

Difficulty: interview

Starter code:

Solutions:
rndid = "cuuhkjc"
for _ in range(int(input())):
  input()
  ls = 'a' * 51
  oa = ord('a')
  print(ls)
  for a in input().split():
    a = int(a)
    ls = ls[:a] + ls[a:].translate({oa: 'b', oa + 1: 'a'})
    print(ls)

# ------------------- fast io --------------------
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")

# ------------------- fast io --------------------
from math import gcd, ceil

def pre(s):
    n = len(s)
    pi = [0] * n
    for i in range(1, n):
        j = pi[i - 1]
        while j and s[i] != s[j]:
            j = pi[j - 1]
        if s[i] == s[j]:
            j += 1
        pi[i] = j
    return pi


def prod(a):
    ans = 1
    for each in a:
        ans = (ans * each)
    return ans

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


def binary(x, length=16):
    y = bin(x)[2:]
    return y if len(y) >= length else "0" * (length - len(y)) + y


for _ in range(int(input()) if True else 1):
    n = int(input())
    #n, k = map(int, input().split())
    #a, b = map(int, input().split())
    #c, d = map(int, input().split())
    a = list(map(int, input().split()))
    #b = list(map(int, input().split()))
    #s = input()
    ans = ['a'*100]
    for i in range(n):
        ans += [ans[-1][:a[i]] + chr(ord(ans[-1][a[i]])+1) if ans[-1][a[i]] != 'z' else 'a']
        ans[-1] = ans[-1] + "a"*(100 - len(ans[-1]))
    for each in ans:
        print(each)

def nxt(ch):
    if ch == 'z':
        return 'a'
    return chr(ord(ch) + 1)


ans = []
for _ in range(int(input())):
    n = int(input())
    u = list(map(int, input().split()))
    s = ['a']
    for i in range(51):
        s.append(nxt(s[-1]))
    ans.append(''.join(s))
    for i in range(n):
        s[u[i]] = nxt(s[u[i]])
        ans.append(''.join(s))
print('\n'.join(ans))


from bisect import bisect_left as bl
from bisect import bisect_right as br
from heapq import heappush,heappop,heapify
import math
from collections import *
from functools import reduce,cmp_to_key
import sys
input = sys.stdin.readline
M = mod = 998244353
def factors(n):return sorted(set(reduce(list.__add__, ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0))))
def inv_mod(n):return pow(n, mod - 2, mod)
 
def li():return [int(i) for i in input().rstrip('\n').split()]
def st():return input().rstrip('\n')
def val():return int(input().rstrip('\n'))
def li2():return [i for i in input().rstrip('\n')]
def li3():return [int(i) for i in input().rstrip('\n')]


for _ in range(val()):
	n = val()
	l = li()
	ans = ['a' * 100]
	for i in l:
		# print(i)
		last = ans[-1]
		curr = ''
		for j in range(i):
			curr += last[j]

		toadd = 'b' if last[i] == 'a' else 'a'
		curr += toadd * (100 - len(curr))
		ans.append(curr[:])
	for i in ans:print(i)
	


t = int(input())
for _ in range(t):
    n = int(input())
    a = [int(x) for x in input().split()]
    b = ord('a')
    s = 'a' * 200
    print(s)
    for i in range(n):
        b += 1
        if b == ord('z'):
            b = ord('a')
        s = s[:a[i]] + chr(b) * (200 - a[i])
        print(s)

for _ in range(int(input())):
    _ = int(input())
    *arr, = list(map(int, input().split()))
    max_len = max(arr) + 1
    ans = ['a'] * max_len
    print(''.join(ans))
    for n in arr:
        if ans[n] == 'a':
            ans[n] = 'b'
        else:
            ans[n] = 'a'
        print(''.join(ans))



 
# from math import factorial as fac
from collections import defaultdict
# from copy import deepcopy
import sys, math
f = None
try:
	f = open('q1.input', 'r')
except IOError:
	f = sys.stdin
if 'xrange' in dir(__builtins__):
	range = xrange
# print(f.readline())
# sys.setrecursionlimit(10**6)

	
def print_case_iterable(case_num, iterable):
	print("Case #{}: {}".format(case_num," ".join(map(str,iterable))))

def print_case_number(case_num, iterable):
	print("Case #{}: {}".format(case_num,iterable))

def print_iterable(A):
	print (' '.join(A))

def read_int():
	return int(f.readline().strip())
def read_int_array():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def read_string():
	return list(f.readline().strip())
def ri():
	return int(f.readline().strip())
def ria():
	return [int(x) for x in f.readline().strip().split(" ")]
def rns():
	a =  [x for x in f.readline().split(" ")]
	return int(a[0]), a[1].strip()
def rs():
	return list(f.readline().strip())
def bi(x):
	return bin(x)[2:]





from collections import deque
import math
NUMBER = 10**9 + 7
# NUMBER = 998244353
def factorial(n) : 
	M = NUMBER
	f = 1
  
	for i in range(1, n + 1):  
		f = (f * i) % M # Now f never can  
						# exceed 10^9+7  
	return f
def mult(a,b):
	return (a * b) % NUMBER

def minus(a , b):
	return (a - b) % NUMBER

def plus(a , b):
	return (a + b) % NUMBER

def egcd(a, b):
	if a == 0:
		return (b, 0, 1)
	else:
		g, y, x = egcd(b % a, a)
		return (g, x - (b // a) * y, y)

def modinv(a):
	m = NUMBER
	g, x, y = egcd(a, m)
	if g != 1:
		raise Exception('modular inverse does not exist')
	else:
		return x % m
def choose(n,k):
	if n < k:
		assert false
	return  mult(factorial(n), modinv(mult(factorial(k),factorial(n-k)))) % NUMBER
from collections import deque, defaultdict 
import heapq


from types import GeneratorType
def bootstrap(f, stack=[]):
	def wrappedfunc(*args, **kwargs):
		if stack:
			return f(*args, **kwargs)
		else:
			to = f(*args, **kwargs)
			while True:
				if type(to) is GeneratorType:
					stack.append(to)
					to = next(to)
				else:
					stack.pop()
					if not stack:
						break
					to = stack[-1].send(to)
			return to

	return wrappedfunc


def dfs(g, timeIn, timeOut,depths,parents): 
	# assign In-time to node u 
	cnt = 0
	# node, neig_i, parent, depth
	stack = [[1,0,0,0]]
	while stack:
		v,neig_i,parent,depth = stack[-1]
		parents[v] = parent
		depths[v] = depth
		# print (v)
		if neig_i == 0:
			timeIn[v] = cnt    
			cnt+=1
		while neig_i < len(g[v]):
			u = g[v][neig_i]
			if u == parent:
				neig_i+=1
				continue
			stack[-1][1] = neig_i + 1
			stack.append([u,0,v,depth+1])
			break
		if neig_i == len(g[v]):
			stack.pop()
			timeOut[v] = cnt
			cnt += 1
  
# def isAncestor(u: int, v: int, timeIn: list, timeOut: list) -> str: 
# 	return timeIn[u] <= timeIn[v] and timeOut[v] <= timeOut[u] 

cnt = 0
@bootstrap
def dfs(v,adj,timeIn, timeOut,depths,parents,parent=0,depth=0):
	nonlocal cnt
	parents[v] = parent
	depths[v] = depth
	timeIn[v] = cnt
	cnt+=1
	for u in adj[v]:
		if u == parent:
			continue
		yield dfs(u,adj,timeIn,timeOut,depths,parents,v,depth+1)
	timeOut[v] = cnt
	cnt+=1
	yield 

def gcd(a,b): 
	if a == 0: 
		return b 
	return gcd(b % a, a) 
  
# Function to return LCM of two numbers 
def lcm(a,b): 
	return (a*b) / gcd(a,b) 
def get_num_2_5(n):
	twos = 0
	fives = 0
	while n>0 and n%2 == 0:
		n//=2
		twos+=1
	while n>0 and n%5 == 0:
		n//=5
		fives+=1
	return (twos,fives)
def shift(a,i,num):
	for _ in range(num):
		a[i],a[i+1],a[i+2] = a[i+2],a[i],a[i+1]

def equal(x,y):
	return abs(x-y) <= 1e-9
# def leq(x,y):
# 	return x-y <= 1e-9
def getAngle(a, b, c):
	ang = math.degrees(math.atan2(c[1]-b[1], c[0]-b[0]) - math.atan2(a[1]-b[1], a[0]-b[0]))
	return ang + 360 if ang < 0 else ang
def getLength(a,b):
	return math.sqrt((a[0]-b[0])**2 + (a[1]-b[1])**2)


from heapq import heapify, heappush, heappop

def bfs(adj):
	s = set()
	d = defaultdict(set)
	# print('\n'.join(map(str,E.items())))
	q = deque([])
	s.add(0)
	d[0].add(0)
	q.append((0,0))
	while len(q) > 0:
		v,depth = q.popleft()
		for u in adj[v]:
			if u not in s:
				s.add(u)
				d[depth+1].add(u)
				q.append((u,depth+1))
		# print(q)
	return d


@bootstrap
def dfs(u,top, adj,vis):
	vis[u] = 1
	for v,d in adj[u]:
		if vis[v]==2 or d==0:
			continue
		if vis[v] == 1:
			yield "No"
		x = yield dfs(v,top,adj,vis)
		if x == "No":
			yield "No"
	vis[u] = 2
	top.append(u)
	yield
def isSubsetSum(arr, n, summ): 
      
    # The value of subarr[i][j] will be  
    # true if there is a 
    # subarr of arr[0..j-1] with summ equal to i 
    subarr =([[False for i in range(summ + 1)]  
            for i in range(n + 1)]) 
      
    # If summ is 0, then answer is true  
    for i in range(n + 1): 
        subarr[i][0] = True
          
    # If summ is not 0 and arr is empty,  
    # then answer is false  
    for i in range(1, summ + 1): 
         subarr[0][i]= False
              
    # Fill the subarr table in botton up manner 
    for i in range(1, n + 1): 
        for j in range(1, summ + 1): 
            if j<arr[i-1]: 
                subarr[i][j] = subarr[i-1][j] 
            if j>= arr[i-1]: 
                subarr[i][j] = (subarr[i-1][j] or 
                                subarr[i - 1][j-arr[i-1]]) 
      
    # uncomment this code to print table  
    # for i in range(n + 1): 
    # for j in range(summ + 1): 
    # print (subset[i][j], end =" ") 
    # print() 
    return subarr[n][summ] 

def find_lcm(a,b): 
	return (a*b) // gcd(a,b) 
def find_lcm_array(A):
	if len(A) == 1:
		return A[0]
	lcm = find_lcm(A[0], A[1] ) 

	for i in range(2, len(A)): 
		lcm = find_lcm(lcm, A[i]) 
	return lcm

def solution(a,n):
	res = ['a'*50]
	for i in range(n):
		x = a[i]
		if x== 50:
			res.append(res[-1])
			continue
		temp = res[-1]
		char = res[-1][x]
		char = 'a' if char == 'z' else 'z'
		res.append(temp[:x]+char+temp[x+1:])
	return '\n'.join(res)

		

	




def main():
	T = 1
	T = ri()
	for i in range(T):
		n = ri()
		a = ria()
		# s = rs()
		# n,m,k	= ria()
		# adj = [list() for _ in range(n)]
		# for _ in range(m):
		# 	d,a,b=ria();
		# 	a-=1; b-=1
		# 	adj[a].append((b,d))
		# 	if d == 0:
		# 		adj[b].append((a,d))

		x = solution(a,n)

		# continue
		if 'xrange' not in dir(__builtins__):
			print(x) # print("Case #"+str(i+1)+':',x)
		else:
			print >>output,"Case #"+str(i+1)+':',str(x)
	if 'xrange' in dir(__builtins__):
		print(output.getvalue())
		output.close()

if 'xrange' in dir(__builtins__):
	import cStringIO
	output = cStringIO.StringIO()
#example usage:
#    for l in res:
#       print >>output, str(len(l)) + ' ' +  ' '.join(l)

def __starting_point():
	main()
__starting_point()

from sys import stdin
"""
n=int(stdin.readline().strip())
n,m=map(int,stdin.readline().strip().split())
s=list(map(int,stdin.readline().strip().split()))
"""
T=int(stdin.readline().strip())
let=[chr(i) for i in range(97,97+26)]
for caso in range(T):
    n=int(stdin.readline().strip())
    s=list(map(int,stdin.readline().strip().split()))
    ans=["a"*110]
    for i in range(n):
        x=ans[-1][0:s[i]]
        for j in let:
            if j!=ans[-1][s[i]]:
                x+=j
                break
        x+=ans[-1][s[i]+1::]
        ans.append(x)
    for i in ans:
        print(i)
            
    
    
    


import sys, os.path
from collections import deque
from fractions import Fraction as f
def IO():
    if os.path.exists('input.txt'):
        sys.stdin = open('input.txt', 'r')
        sys.stdout = open('output.txt', 'w')
    else:
        input=sys.stdin.readline
        print=sys.stdout.write
def nextInt():
    return int(input())
def nextTuple():
    return [int(a) for a in input().split()]
def nextArray():
    return list(map(int, input().split()))
def nextLine():
    return input()
def nextStringArray():
    return list(input().split())
IO()

'''code starts here'''


t=int(input())
for _ in range(t):
    n=int(input())
    a=list(map(int,input().split()))
    s="abcdefghijklmnopqrstuvwxyz"
    dict={}
    for i in range(25):
        dict[s[i]]=s[i+1]
    dict['z']='a'
    s="a"*200
    print(s)
    for i in range(n):
        p=s[0:a[i]]+dict[s[a[i]]]+s[a[i]+1:]
        s=p
        print(p)


alphabet = "qwertyuiopasdfghjklzxcvbnm"


def solve():
    n = int(input())
    a = list(map(int, input().split()))
    last = "a" * 51
    print(last)
    for i in range(n):
        last = last[:a[i]] + alphabet[alphabet.index(last[a[i]]) - 1] + "a" * 50
        print(last)


for _ in range(int(input())):
    solve()


import sys


#def solve(a,b,c,d):
def solve(lens):
    base = ord('a')
    wlen = max(lens)+2
    last = ['a']*wlen
    word_list = [''.join(last)]
    for l in lens:
        last[l] = chr( base + (ord(last[l])-ord('a')+1)%26 )
        word_list.append(''.join(last))
    return word_list


def __starting_point():
    IN = [x.strip() for x in sys.stdin.readlines()]

    T = int(IN[0])
    cur = 1
    for ti in range(T):
        a = int(IN[cur])
        #a = [int(x) for x in IN[cur].split(' ')]
        lens = [int(x) for x in IN[cur+1].split(' ')]
        res = solve(lens)
        for w in res:
            print(w)
        cur += 2


__starting_point()

maxs = 190
t = int(input())
for _ in range(t):
	n = int(input())
	arr = [int(j) for j in input().split()]
	ans = [0]*(n+1)
	ans[0] = 'a'*maxs
	for i in range(1, n+1):
		num = arr[i-1]
		current = ''
		for j in range(num):
			current += ans[i-1][j]
		if ans[i-1][num] == 'a':
			current += 'b'
		else:
			current += 'a'

		for j in range(num+1, maxs):
			current += current[j-1]

		ans[i] = current
	print(*ans, sep='\n')

import sys
INP = lambda: sys.stdin.readline().strip()
INT = lambda: int(INP())
MAP = lambda: list(map(int, INP().split()))
ARR = lambda: [int(i) for i in INP().split()]
def JOIN(arr, x=''): return x.join([str(i) for i in arr])
def EXIT(x='NO'): print(x); return

for _ in range(INT()):
    n = INT()
    arr = ARR()
    ans = list('ab'*(max(arr)//2 + 1))
    print(JOIN(ans))
    for x in arr:
        ans[x] = 'b' if ans[x]=='a' else 'a'
        print(JOIN(ans))



def solve():
    n = int(input())
    s = input().split()

    m = 0
    
    for i in range(len(s)):
        s[i] = int(s[i])
        m = max(m, s[i])
    print('a'*(m + 1))
    cur = ['a']*(m + 1)
    for i in range(len(s)):
        if cur[s[i]] == 'a':
            cur[s[i]] = 'b'
        else:
            cur[s[i]] = 'a'
        print(''.join(cur))
        


t = int(input())

for i in range(t):
    solve()




#------------------------template--------------------------#
import os
import sys
from math import *
from collections import *
from fractions import *
from bisect import *
from heapq import*
from io import BytesIO, IOBase
def vsInput():
    sys.stdin = open('input.txt', 'r')
    sys.stdout = open('output.txt', 'w')
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 value():return tuple(map(int,input().split()))
def array():return [int(i) for i in input().split()]
def Int():return int(input())
def Str():return input()
def arrayS():return [i for i in input().split()]

#-------------------------code---------------------------#
# vsInput()

char='qwertyuiopasdfghjklxcvbnm'

for _ in range(Int()):
    n=Int()
    a=array()

    ma=max(a)

    id=0
    s=['z' for i in range(ma+1)]
    print(*s,sep="")

    for i in range(1,n+1):
        id=(id+1)%25
        s[a[i-1]]=char[id]
        print(*s,sep="")