description: Polycarp has come up with a new game to play with you. He calls it "A missing bigram".
  
  A bigram of a word is a sequence of two adjacent letters in it.
  
  For example, word "abbaaba" contains bigrams "ab", "bb", "ba", "aa", "ab" and "ba".
  
  The game goes as follows. First, Polycarp comes up with a word, consisting only of lowercase letters 'a' and 'b'. Then, he writes down all its bigrams on a whiteboard in the same order as they appear in the word. After that, he wipes one of them off the whiteboard.
  
  Finally, Polycarp invites you to guess what the word that he has come up with was.
  
  Your goal is to find any word such that it's possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.
  
  The tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them.
  
  Input
  
  The first line contains a single integer t (1 ≤ t ≤ 2000) — the number of testcases.
  
  The first line of each testcase contains a single integer n (3 ≤ n ≤ 100) — the length of the word Polycarp has come up with.
  
  The second line of each testcase contains n-2 bigrams of that word, separated by a single space. Each bigram consists of two letters, each of them is either 'a' or 'b'.
  
  Additional constraint on the input: there exists at least one string such that it is possible to write down all its bigrams, except one, so that the resulting sequence is the same as the sequence in the input. In other words, the answer exists.
  
  Output
  
  For each testcase print a word, consisting of n letters, each of them should be either 'a' or 'b'. It should be possible to write down all its bigrams and remove one of them, so that the resulting sequence of bigrams is the same as the one Polycarp ended up with.
  
  The tests are generated in such a way that the answer exists. If there are multiple answers, you can print any of them. 
  
  Example
  
  Input
  
  
  4
  7
  ab bb ba aa ba
  7
  ab ba aa ab ba
  3
  aa
  5
  bb ab bb
  
  
  Output
  
  
  abbaaba
  abaabaa
  baa
  bbabb
  
  Note
  
  The first two testcases from the example are produced from the word "abbaaba". As listed in the statement, it contains bigrams "ab", "bb", "ba", "aa", "ab" and "ba".
  
  In the first testcase, the 5-th bigram is removed. 
  
  In the second testcase, the 2-nd bigram is removed. However, that sequence could also have been produced from the word "abaabaa". It contains bigrams "ab", "ba", "aa", "ab", "ba" and "aa". The missing bigram is the 6-th one.
  
  In the third testcase, all of "baa", "aab" and "aaa" are valid answers.
solution:         import java.beans.DesignMode;
          import java.io.BufferedReader;
          import java.io.FileInputStream;
          import java.io.FileNotFoundException;
          import java.io.IOException;
          import java.io.InputStreamReader;
          import java.util.*;
          import java.util.concurrent.LinkedBlockingDeque;
          import java.util.concurrent.CompletableFuture.AsynchronousCompletionTask;
  
          import org.xml.sax.ErrorHandler;
  
          import java.io.PrintStream;
          import java.io.PrintWriter;
          import java.io.DataInputStream;
  
          public class Solution {
                  //TEMPLATE -------------------------------------------------------------------------------------
                  public static boolean Local(){
                      try{ 
                          return System.getenv("LOCAL_SYS")!=null;
                      }catch(Exception e){
                          return false;
                      }
                  }   
  
                  public static boolean LOCAL;
  
                  static class FastScanner {
  
                          BufferedReader br;
                          StringTokenizer st ;
  
                          FastScanner(){
                              br =  new BufferedReader(new InputStreamReader(System.in));
                              st = new StringTokenizer("");
                          }
  
                          FastScanner(String file) {
  
                              try{
                                  br =  new BufferedReader(new InputStreamReader(new FileInputStream(file)));
                                  st = new StringTokenizer("");
                              }catch(FileNotFoundException e) {
                                  // TODO Auto-generated catch block
                                  System.out.println("file not found");
                                  e.printStackTrace();
                              }
                              
                          }
                          String next() {
                              while (!st.hasMoreTokens())
                                  try {
                                      st = new StringTokenizer(br.readLine());
                                  } catch (IOException e) {
                                  }
                              return st.nextToken();
                          }
  
                          int nextInt() {
                              return Integer.parseInt(next());
                          }
  
                          long nextLong() {
                              return Long.parseLong(next());
                          }
  
                          double nextDouble(){
                              return Double.parseDouble(next());
                          }
  
                          String readLine() throws IOException{
                              return br.readLine();
                          }
                      }
                                          
                  static class Pair<T,X> {
  
                      T first;
                      X second;
                      
                      Pair(T first,X second){
                          this.first = first;
                          this.second = second;
                      }
  
                      @Override
                      public int hashCode(){
                          return Objects.hash(first,second);
                      }
  
                      @Override
                      public boolean equals(Object obj){
                          return obj.hashCode() == this.hashCode();
                      }
  
                  }
  
              
              static PrintStream debug = null;      
              static long mod = (long)(Math.pow(10,9) + 7); 
          //TEMPLATE -------------------------------------------------------------------------------------END//
              public static void main(String[] args) throws Exception {
                  
                  FastScanner s = new FastScanner();
                  LOCAL = Local();
                  //PrintWriter pw = new PrintWriter(System.out);
                  if(LOCAL){
                      s = new FastScanner("src/input.txt");
                      PrintStream o = new PrintStream("src/sampleout.txt");
                      debug = new PrintStream("src/debug.txt");
                      System.setOut(o);
                  //  pw = new PrintWriter(o);
                  } long mod = 1000000007;
  
              
                  int tcr = s.nextInt();                  
                  StringBuilder sb = new StringBuilder();
              
  
                  for(int tc=0;tc<tcr;tc++){        
                     int n = s.nextInt();
                     List<Character> list = new ArrayList<>();
                     String start = s.next();
                     for(int i=0;i<2;i++){
                         list.add(start.charAt(i));
                     }
                     for(int i=0;i<n-3;i++){
                         char ar[] = s.next().toCharArray();
                         if(list.get(list.size()-1) == ar[0]){
                             list.add(ar[1]);
                         }else{
                             list.add(ar[0]);
                             list.add(ar[1]);
                         }
                     }
                     if(list.size() < n){
                          list.add('b');
                     }
                     for(int i=0;i<list.size();i++){
                         sb.append(list.get(i));
                     }
                     sb.append('\n');
                  }
  
                  print(sb.toString());
              }
  
  
              public static List<int[]> print_prime_factors(int n){
              
                  List<int[]> list = new ArrayList<>();
                  
                  for(int i=2;i<=(int)(Math.sqrt(n));i++){
  
                      if(n % i == 0){
                          
                          int cnt = 0;
                          
                          while( (n % i) == 0){
                              n = n/i;
                              cnt++;
                          }
  
                          list.add(new int[]{i,cnt});
                      }
                  }
  
                  if(n!=1){
                      list.add(new int[]{n,1});
                  }
  
                  return list;
              }
  
              public static List<int[]> prime_factors(int n,List<Integer> sieve){
                  List<int[]> list = new ArrayList<>();
                  int index = 0;
                  while(n > 1 && sieve.get(index) <= Math.sqrt(n)){
                      int curr = sieve.get(index);
                      int cnt = 0;
                      while((n % curr) == 0){
                          n = n/curr;
                          cnt++;
                      }
                      if(cnt >= 1){
                          list.add(new int[]{curr,cnt});
                      }
                      index++;
                  }
                  if(n > 1){
                      list.add(new int[]{n,1});
                  }
                  return list;
              }
  
              public static boolean inRange(int r1,int r2,int val){
                  return ((val >= r1) && (val <= r2));
              }
  
              static int len(long num){
                  return Long.toString(num).length();
              }
  
              static long mulmod(long a, long b,long mod)
              {
                  long ans = 0l;
                  
                  while(b > 0){
                      long curr = (b & 1l);
                      if(curr == 1l){
                          ans = ((ans % mod) + a) % mod;
                      }
                      
                      a = (a + a) % mod;
  
                      b = b >> 1;
                  }
  
                  return ans;
              }
  
  
              public static void dbg(PrintStream ps,Object... o) throws Exception{
                  if(ps == null){
                      return;
                  }
                  Debug.dbg(ps,o);
              }
  
              public static long modpow(long num,long pow,long mod){
  
                  long val = num;
                  long ans = 1l;
  
                  while(pow > 0l){
                      
                      long bit = pow & 1l;
  
                      if(bit == 1){
                          ans = (ans * (val%mod))%mod;
                      }
  
                      val = (val * val) % mod;
                      pow = pow >> 1;
                  }
  
                  return ans;
  
              }
  
              public static long pow(long num,long pow){
  
                  long val = num;
                  long ans = 1l;
  
                  while(pow > 0l){
                      
                      long bit = pow & 1l;
  
                      if(bit == 1){
                          ans = (ans * (val));
                      }
  
                      val = (val * val);
                      pow = pow >> 1;
                  }
  
                  return ans;
              }
              
              public static char get(int n){
                  return (char)('a' + n);
              }
  
              public static long[] sort(long arr[]){
                  List<Long> list = new ArrayList<>();
                  for(long n : arr){list.add(n);}
                  Collections.sort(list);
                  for(int i=0;i<arr.length;i++){
                      arr[i] = list.get(i);
                  }
                  return arr;
              }
  
              public static int[] sort(int arr[]){
                  List<Integer> list = new ArrayList<>();
                  for(int n : arr){list.add(n);}
                  Collections.sort(list);
                  for(int i=0;i<arr.length;i++){
                      arr[i] = list.get(i);
                  }
                  return arr;
              }
  
              // return the (index + 1)
              // where index is the pos of just smaller element
              // i.e count of elemets strictly less than num
              public static int justSmaller(long arr[],long num){
                  //  System.out.println(num+"@");
                  int st = 0;
                  int e = arr.length - 1;
  
                  int ans = -1;
  
                  while(st <= e){
  
                      int mid = (st + e)/2;
  
                      if(arr[mid] >= num){
                          e = mid - 1;
                      }else{
                          ans = mid;
                          st = mid + 1;
                      }
  
                  }
  
  
                  return ans + 1;
  
              }
              public static int justSmaller(int arr[],int num){
                  //  System.out.println(num+"@");
                  int st = 0;
                  int e = arr.length - 1;
  
                  int ans = -1;
  
                  while(st <= e){
  
                      int mid = (st + e)/2;
  
                      if(arr[mid] >= num){
                          e = mid - 1;
                      }else{
                          ans = mid;
                          st = mid + 1;
                      }
  
                  }
  
  
                  return ans + 1;
  
              }
              
              //return (index of just greater element)
              //count of elements smaller than or equal to num
  
              public static int justGreater(long arr[],long num){
                  int st = 0;
                  int e = arr.length - 1;
  
                  int ans = arr.length;
  
                  while(st <= e){
                      
                      int mid = (st + e)/2;
  
                      if(arr[mid] <= num){
                          st = mid + 1;
                      }else{
                          ans = mid;
                          e = mid - 1;
                      }
                  }
  
                  return ans;
  
              }
  
              public static int justGreater(int arr[],int num){
                  int st = 0;
                  int e = arr.length - 1;
  
                  int ans = arr.length;
  
                  while(st <= e){
                      
                      int mid = (st + e)/2;
  
                      if(arr[mid] <= num){
                          st = mid + 1;
                      }else{
                          ans = mid;
                          e = mid - 1;
                      }
                  }
  
                  return ans;
  
              }
  
              
  
              public static void println(Object obj){
                  System.out.println(obj.toString());
              }
  
              public static void print(Object obj){
                  System.out.print(obj.toString());
              }
  
              public static int gcd(int a,int b){
                  if(b == 0){return a;}
                  return gcd(b,a%b);
              }
  
              public static long gcd(long a,long b){
                  if(b == 0l){
                      return a;
                  }
  
                  return gcd(b,a%b);
              }
  
              public static int find(int parent[],int v){
                  if(parent[v] == v){
                      return v;
                  }
                  
                  return parent[v] = find(parent, parent[v]);
              }
  
  
  
              public static List<Integer> sieve(){
              
                      List<Integer> prime = new ArrayList<>();
  
                      int arr[] = new int[1000001];
  
                  Arrays.fill(arr,1);
  
                  arr[1] = 0;
                  arr[2] = 1;
  
                  for(int i=2;i<1000001;i++){
                      
                      if(arr[i] == 1){
                          
                          prime.add(i);
  
                          for(long j = (i*1l*i);j<1000001;j+=i){
                              arr[(int)j] = 0;
                          }
                      }
                  }
  
                  return prime;
              }
  
              static boolean isPower(long n,long a){
                  
                  long log = (long)(Math.log(n)/Math.log(a));
  
                  long power = (long)Math.pow(a,log);
  
                  if(power == n){return true;}
  
                  return false;
              }
  
  
              private static int mergeAndCount(int[] arr, int l,int m, int r)
              {
                  // Left subarray
                  int[] left =  Arrays.copyOfRange(arr, l, m + 1);
  
                  // Right subarray
                  int[] right = Arrays.copyOfRange(arr, m + 1, r + 1);
  
                  int i = 0, j = 0, k = l, swaps = 0;
  
                  while (i < left.length && j < right.length) {
                      if (left[i] <= right[j])
                          arr[k++] = left[i++];
                      else {
                          arr[k++] = right[j++];
                          swaps += (m + 1) - (l + i);
                      }
                  }
                  while (i < left.length)
                      arr[k++] = left[i++];
                  while (j < right.length)
                      arr[k++] = right[j++];
                  return swaps;
              }
  
              // Merge sort function
              private static int mergeSortAndCount(int[] arr, int l,int r)
              {
  
                  // Keeps track of the inversion count at a
                  // particular node of the recursion tree
                  int count = 0;
  
                  if (l < r) {
                      int m = (l + r) / 2;
  
                      // Total inversion count = left subarray count
                      // + right subarray count + merge count
  
                      // Left subarray count
                      count += mergeSortAndCount(arr, l, m);
  
                      // Right subarray count
                      count += mergeSortAndCount(arr, m + 1, r);
  
                      // Merge count
                      count += mergeAndCount(arr, l, m, r);
                  }
  
                  return count;
              }
  
              static class Debug{
                  //change to System.getProperty("ONLINE_JUDGE")==null; for CodeForces
                  public static final boolean LOCAL = System.getProperty("ONLINE_JUDGE")==null;
  
                  
  
                  private static <T> String ts(T t) {
                      if(t==null) {
                          return "null";
                      }
                      try {
                          return ts((Iterable<T>) t);
                      }catch(ClassCastException e) {
                          if(t instanceof int[]) {
                              String s = Arrays.toString((int[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof long[]) {
                              String s = Arrays.toString((long[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof char[]) {
                              String s = Arrays.toString((char[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof double[]) {
                              String s = Arrays.toString((double[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }else if(t instanceof boolean[]) {
                              String s = Arrays.toString((boolean[]) t);
                              return "{"+s.substring(1, s.length()-1)+"}\n";
                          }
                          try {
                              return ts((Object[]) t);
                          }catch(ClassCastException e1) {
                              return t.toString();
                          }
                      }
                  }
                  private static <T> String ts(T[] arr) {
                      StringBuilder ret = new StringBuilder();
                      ret.append("{");
                      boolean first = true;
                      for(T t: arr) {
                          if(!first) {
                              ret.append(", ");
                          }
                          first = false;
                          ret.append(ts(t));
                      }
                      ret.append("}");
                      return ret.toString();
                  }
                  private static <T> String ts(Iterable<T> iter) {
                      StringBuilder ret = new StringBuilder();
                      ret.append("{");
                      boolean first = true;
                      for(T t: iter) {
                          if(!first) {
                              ret.append(", ");
                          }
                          first = false;
                          ret.append(ts(t));
                      }
                      ret.append("}\n");
                      return ret.toString();
                  }
                  public static void dbg(PrintStream ps,Object... o) throws Exception {
                      if(LOCAL) {
                          System.setErr(ps);
                          System.err.print("Line #"+Thread.currentThread().getStackTrace()[2].getLineNumber()+": [\n");
                          for(int i = 0; i<o.length; i++) {
                              if(i!=0) {
                                  System.err.print(", ");
                              }
                              System.err.print(ts(o[i]));
                          }
                          System.err.println("]");
                      }
                  }
              }
  
          }