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

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

For each i (1 ≤ i ≤ 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, ..., s_{n+1} which would have generated numbers a_1, a_2, ..., 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 ≤ t ≤ 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 ≤ n ≤ 100) — the number of elements in the list a.

The second line of each test case contains n integers a_1, a_2, …, a_n (0 ≤ a_i ≤ 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 ≤ |s_i| ≤ 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 → 1 
  * Between \color{red}{ar}i and \color{red}{ar}ousal → 2 
  * Between \color{red}{arou}sal and \color{red}{arou}nd → 4 
  * Between \color{red}{ar}ound and \color{red}{ar}i → 2 

Solution (in JAVA):

Solution:
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.text.Bidi;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.StringTokenizer;
import java.util.TreeMap;


public class COVID {

	static ArrayList<Integer>[] adjList;

	static int mod;
static int INF=(int)1e6;

public static void main(String[] args) throws Exception {

		Scanner	sc = new Scanner(System.in);
		PrintWriter pw= new PrintWriter(System.out);
		int t=sc.nextInt();
		while(t-->0) {
			int n=sc.nextInt();
			int[] arr=sc.nextIntArr(n);
			char[] ans=new char[100];
			for(int i=0;i<ans.length;i++)
				ans[i]='a';
			for(char c:ans)
				pw.print(c);
			pw.println();
			for(int i=0;i<arr.length;i++) {
				ans[arr[i]]^='a'^'b';
				for(char c:ans)
					pw.print(c);
				pw.println();
			
				
			}
				
		}
		pw.close();
	}

	


	static long gcd(long a, long b) {
		return (b==0)?a:gcd(b,a%b);
	}
	static long lcm(long a, long b) {
		return a/gcd(a,b)*b;
	}
	public static int log(int n , int base) {
		int ans=0;
		while(n+1>base) {
			ans++;
			n/=base;
		}
		return ans;
	}
	static int pow(int b,long e) {
		int ans=1;
		while(e>0) {
			if((e&1)==1)
				ans=(int)((ans*1l*b));
			e>>=1;{

			}
			b=(int)((b*1l*b));
		}
		return ans;
	}
	static long powmod(long b,long e, int mod) {
		long ans=1;
		b%=mod;
		while(e>0) {
			if((e&1)==1)
				ans=(int)((ans*1l*b)%mod);
			e>>=1;
			b=(int)((b*1l*b)%mod);
		}
		return ans;
	}
	public static long add(long a, long b) {
		return (a+b)%mod;
	}
	public static long mul(long a, long b) {
		return ((a%mod)*(b%mod))%mod;
	}



static public class SegmentTree {
	int N;
	int[] array,sTree,lazy;
//	boolean[] marked; // if marked[i]=true this means that sTree[i] is the same value for all of it's children


	public SegmentTree(int[] arr) {//note arr must be 1 based arr
		array=arr;
		N=arr.length-1;// arr must be power of 2 and 1 based array
		sTree=new int[N<<1]; // no of nodes is 2N-1 but we add 1 to be 1 index
		lazy=new int[N<<1];
		//	marked=new boolean[N<<1];
//		build(1,1,N);

	}
	
public  void build(int v,int b ,int e) {//o(N)
		if(b==e) {
			sTree[v]=array[b];
		}else {
			int mid =(b+e)>>1;
		build((v<<1),b,mid);
		build((v<<1)|1,mid+1,e);

		sTree[v]=sTree[v<<1]+sTree[(v<<1)|1];	
		}
	}


	public int query(int i, int j) {//O(2log(n))
		return query(1, 1,N,i,j);
	}

	public int query(int node , int b ,int e , int i , int j) {
		if(b>j||e<i)return 0;
		if(b>=i&&e<=j)return sTree[node];
		int mid =(b+e)>>1;
		propagate(node, b, mid, e);// we propagate the delayed updated because we add left & right child 
		int leftChild =query(node<<1, b,mid,i,j);
		int rightChild =query((node<<1)|1, mid+1,e,i,j);
		return leftChild+rightChild;
	}

	public void set_point(int idx,int val) {
		idx+=N-1;
		sTree[idx]=val;
		while(idx>1) {
			idx>>=1;
		sTree[idx]=sTree[idx<<1]+sTree[idx<<1|1];
		}
	}


	public void update_point(int idx , int val) {
		idx+=N-1;
		sTree[idx]+=val;
		while(idx>1) {
			idx>>=1;//divide by 2 to get the parent
		sTree[idx]=sTree[(idx<<1)]+sTree[(idx<<1)|1];
		}

	}





	public void update_range(int i , int j , int val) {
		update_range(1,1, N, i,j,val);
	}



	public void update_range(int node,int b,int e ,int i , int j , int val) {
		if(e<i||b>j)return;
		if(b>=i&&e<=j) {
			sTree[node]+=(e-b+1)*val;
			lazy[node]+=val;

		}else {

			int mid =(b+e)>>1;
		propagate(node, b , mid , e);//we make propagate because after these call we make 	sTree[node]=sTree[node<<1]+sTree[node<<1 |1];
		// so it must be the correct value
		update_range(node<<1, b, mid, i, j, val);
		update_range(node<<1|1, mid+1, e, i, j, val);
		sTree[node]=sTree[node<<1]+sTree[node<<1 |1];
		}
	}


	public  void propagate(int node , int b ,int mid , int e) { //O(1)
		lazy[node<<1]+=lazy[node];
		lazy[node<<1|1]+=lazy[node];
		sTree[node<<1]+=(mid-b+1)*lazy[node];
		sTree[node<<1|1]+=(e-mid)*lazy[node];
		lazy[node]=0;
	}


}





	
static class Pair implements Comparable<Pair>{

		int  x;int y;



		public Pair(int a,int b) {
			this.x=a;y=b;
		}









		public int compareTo(Pair o) {
			return (x==o.x)?((y>o.y)?1:(y==o.y)?0:-1):((x>o.x)?1:-1);
			//		return y-o.y;
		}


		@Override




		public int hashCode() {
			final int prime = 31;
			int result = 1;
			result = prime * result + x;
			result = prime * result + y;
			return result;
		}


		@Override


		public boolean equals(Object obj) {
			if (this == obj)
				return true;
			if (obj == null)
				return false;
			if (getClass() != obj.getClass())
				return false;
			Pair other = (Pair) obj;
			if (x != other.x)
				return false;
			if (y != other.y)
				return false;
			return true;
		}

	}







	static class Scanner {
		StringTokenizer st;
		BufferedReader br;

		public Scanner(InputStream s) {
			br = new BufferedReader(new InputStreamReader(s));
		}
		public Scanner(String s) throws FileNotFoundException{	br = new BufferedReader(new FileReader(s));}

		public long[] nextLongArr(int n) throws IOException {
			long[] arr=new long[n];
			for(int i=0;i<n;i++)
				arr[i]=nextLong();
			return arr;
		}
		public int[] nextIntArr(int n) throws IOException {
			int[] arr=new int[n];
			for(int i=0;i<n;i++)
				arr[i]=nextInt();
			return arr;
		}
		public String next() throws IOException {
			while (st == null || !st.hasMoreTokens())
				st = new StringTokenizer(br.readLine()," ,");
			return st.nextToken();
		}

		public int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		public long nextLong() throws IOException {
			return Long.parseLong(next());
		}

		public String nextLine() throws IOException {
			return br.readLine();
		}


		public double nextDouble() throws IOException {
			String x = next();
			StringBuilder sb = new StringBuilder("0");
			double res = 0, f = 1;
			boolean dec = false, neg = false;
			int start = 0;
			if (x.charAt(0) == '-') {
				neg = true;
				start++;
			}
			for (int i = start; i < x.length(); i++) {
				if (x.charAt(i) == '.') {
					res = Long.parseLong(sb.toString());
					sb = new StringBuilder("0");
					dec = true;
				} else {
					sb.append(x.charAt(i));
					if (dec)
						f *= 10;
				}
				if (sb.length() == 18) {
					res += Long.parseLong(sb.toString()) / f;
					sb = new StringBuilder("0");
				}
			}
			res += Long.parseLong(sb.toString()) / f;
			return res * (neg ? -1 : 1);
		}

		public boolean ready() throws IOException {
			return br.ready();
		}

	}

	public static void shuffle(int[] a) {
		int n = a.length;
		for (int i = 0; i < n; i++) {
			int r = i + (int) (Math.random() * (n - i));
			int tmp = a[i];
			a[i] = a[r];
			a[r] = tmp;
		}
	}
}