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 javax.management.MBeanRegistration;
  import java.io.*;
  import java.util.*;
  public class Main {
      private boolean oj = System.getProperty("ONLINE_JUDGE") != null;
      private FastWriter wr;
      private Reader rd;
      public final int MOD = 1000000007;
  
      /************************************************** FAST INPUT IMPLEMENTATION *********************************************/
      class Reader {
          BufferedReader br;
          StringTokenizer st;
  
          public Reader() {
              br = new BufferedReader(
                      new InputStreamReader(System.in));
          }
  
          public Reader(String path) throws FileNotFoundException {
              br = new BufferedReader(
                      new InputStreamReader(new FileInputStream(path)));
          }
  
          String next() {
              while (st == null || !st.hasMoreElements()) {
                  try {
                      st = new StringTokenizer(br.readLine());
                  } catch (IOException e) {
                      e.printStackTrace();
                  }
              }
              return st.nextToken();
          }
  
          int nextInt() {
              return Integer.parseInt(next());
          }
  
          long nextLong() {
              return Long.parseLong(next());
          }
  
          double nextDouble() {
              return Double.parseDouble(next());
          }
  
          String nextLine() {
              String str = "";
              try {
                  str = br.readLine();
              } catch (IOException e) {
                  e.printStackTrace();
              }
              return str;
          }
      }
  
      public int ni() throws IOException {
          return rd.nextInt();
      }
  
      public long nl() throws IOException {
          return rd.nextLong();
      }
  
      char nc() throws IOException {
          return rd.next().charAt(0);
      }
  
      public String ns() throws IOException {
          return rd.nextLine();
      }
  
      public Double nd() throws IOException {
          return rd.nextDouble();
      }
  
      public int[] nai(int n) throws IOException {
          int[] arr = new int[n];
          for (int i = 0; i < n; i++) {
              arr[i] = ni();
          }
          return arr;
      }
  
      public long[] nal(int n) throws IOException {
          long[] arr = new long[n];
          for (int i = 0; i < n; i++) {
              arr[i] = nl();
          }
          return arr;
      }
  
      /************************************************** FAST OUTPUT IMPLEMENTATION *********************************************/
      public static class FastWriter {
          private static final int BUF_SIZE = 1 << 13;
          private final byte[] buf = new byte[BUF_SIZE];
          private final OutputStream out;
          private int ptr = 0;
  
          private FastWriter() {
              out = null;
          }
  
          public FastWriter(OutputStream os) {
              this.out = os;
          }
  
          public FastWriter(String path) {
              try {
                  this.out = new FileOutputStream(path);
              } catch (FileNotFoundException e) {
                  throw new RuntimeException("FastWriter");
              }
          }
  
          public FastWriter write(byte b) {
              buf[ptr++] = b;
              if (ptr == BUF_SIZE) innerflush();
              return this;
          }
  
          public FastWriter write(char c) {
              return write((byte) c);
          }
  
          public FastWriter write(char[] s) {
              for (char c : s) {
                  buf[ptr++] = (byte) c;
                  if (ptr == BUF_SIZE) innerflush();
              }
              return this;
          }
  
          public FastWriter write(String s) {
              s.chars().forEach(c -> {
                  buf[ptr++] = (byte) c;
                  if (ptr == BUF_SIZE) innerflush();
              });
              return this;
          }
  
          private static int countDigits(int l) {
              if (l >= 1000000000) return 10;
              if (l >= 100000000) return 9;
              if (l >= 10000000) return 8;
              if (l >= 1000000) return 7;
              if (l >= 100000) return 6;
              if (l >= 10000) return 5;
              if (l >= 1000) return 4;
              if (l >= 100) return 3;
              if (l >= 10) return 2;
              return 1;
          }
  
          public FastWriter write(int x) {
              if (x == Integer.MIN_VALUE) {
                  return write((long) x);
              }
              if (ptr + 12 >= BUF_SIZE) innerflush();
              if (x < 0) {
                  write((byte) '-');
                  x = -x;
              }
              int d = countDigits(x);
              for (int i = ptr + d - 1; i >= ptr; i--) {
                  buf[i] = (byte) ('0' + x % 10);
                  x /= 10;
              }
              ptr += d;
              return this;
          }
  
          private static int countDigits(long l) {
              if (l >= 1000000000000000000L) return 19;
              if (l >= 100000000000000000L) return 18;
              if (l >= 10000000000000000L) return 17;
              if (l >= 1000000000000000L) return 16;
              if (l >= 100000000000000L) return 15;
              if (l >= 10000000000000L) return 14;
              if (l >= 1000000000000L) return 13;
              if (l >= 100000000000L) return 12;
              if (l >= 10000000000L) return 11;
              if (l >= 1000000000L) return 10;
              if (l >= 100000000L) return 9;
              if (l >= 10000000L) return 8;
              if (l >= 1000000L) return 7;
              if (l >= 100000L) return 6;
              if (l >= 10000L) return 5;
              if (l >= 1000L) return 4;
              if (l >= 100L) return 3;
              if (l >= 10L) return 2;
              return 1;
          }
  
          public FastWriter write(long x) {
              if (x == Long.MIN_VALUE) {
                  return write("" + x);
              }
              if (ptr + 21 >= BUF_SIZE) innerflush();
              if (x < 0) {
                  write((byte) '-');
                  x = -x;
              }
              int d = countDigits(x);
              for (int i = ptr + d - 1; i >= ptr; i--) {
                  buf[i] = (byte) ('0' + x % 10);
                  x /= 10;
              }
              ptr += d;
              return this;
          }
  
          public FastWriter write(double x, int precision) {
              if (x < 0) {
                  write('-');
                  x = -x;
              }
              x += Math.pow(10, -precision) / 2;
              //		if(x < 0){ x = 0; }
              write((long) x).write(".");
              x -= (long) x;
              for (int i = 0; i < precision; i++) {
                  x *= 10;
                  write((char) ('0' + (int) x));
                  x -= (int) x;
              }
              return this;
          }
  
          public FastWriter writeln(char c) {
              return write(c).writeln();
          }
  
          public FastWriter writeln(int x) {
              return write(x).writeln();
          }
  
          public FastWriter writeln(long x) {
              return write(x).writeln();
          }
  
          public FastWriter writeln(double x, int precision) {
              return write(x, precision).writeln();
          }
  
          public FastWriter write(int... xs) {
              boolean first = true;
              for (int x : xs) {
                  if (!first) write(' ');
                  first = false;
                  write(x);
              }
              return this;
          }
  
          public FastWriter write(long... xs) {
              boolean first = true;
              for (long x : xs) {
                  if (!first) write(' ');
                  first = false;
                  write(x);
              }
              return this;
          }
  
          public FastWriter writeln() {
              return write((byte) '\n');
          }
  
          public FastWriter writeln(int... xs) {
              return write(xs).writeln();
          }
  
          public FastWriter writeln(long... xs) {
              return write(xs).writeln();
          }
  
          public FastWriter writeln(char[] line) {
              return write(line).writeln();
          }
  
          public FastWriter writeln(char[]... map) {
              for (char[] line : map) write(line).writeln();
              return this;
          }
  
          public FastWriter writeln(String s) {
              return write(s).writeln();
          }
  
          private void innerflush() {
              try {
                  out.write(buf, 0, ptr);
                  ptr = 0;
              } catch (IOException e) {
                  throw new RuntimeException("innerflush");
              }
          }
  
          public void flush() {
              innerflush();
              try {
                  out.flush();
              } catch (IOException e) {
                  throw new RuntimeException("flush");
              }
          }
  
          public FastWriter print(byte b) {
              return write(b);
          }
  
          public FastWriter print(char c) {
              return write(c);
          }
  
          public FastWriter print(char[] s) {
              return write(s);
          }
  
          public FastWriter print(String s) {
              return write(s);
          }
  
          public FastWriter print(int x) {
              return write(x);
          }
  
          public FastWriter print(long x) {
              return write(x);
          }
  
          public FastWriter print(double x, int precision) {
              return write(x, precision);
          }
  
          public FastWriter println(char c) {
              return writeln(c);
          }
  
          public FastWriter println(int x) {
              return writeln(x);
          }
  
          public FastWriter println(long x) {
              return writeln(x);
          }
  
          public FastWriter println(double x, int precision) {
              return writeln(x, precision);
          }
  
          public FastWriter print(int... xs) {
              return write(xs);
          }
  
          public FastWriter print(long... xs) {
              return write(xs);
          }
  
          public FastWriter println(int... xs) {
              return writeln(xs);
          }
  
          public FastWriter println(long... xs) {
              return writeln(xs);
          }
  
          public FastWriter println(char[] line) {
              return writeln(line);
          }
  
          public FastWriter println(char[]... map) {
              return writeln(map);
          }
  
          public FastWriter println(String s) {
              return writeln(s);
          }
  
          public FastWriter println() {
              return writeln();
          }
      }
  
  
      /********************************************************* USEFUL CODE **************************************************/
      boolean[] SAPrimeGenerator(int n) {
          // TC-N*LOG(LOG N)
          //Create Prime Marking Array and fill it with true value
          boolean[] primeMarker = new boolean[n + 1];
          Arrays.fill(primeMarker, true);
          primeMarker[0] = false;
          primeMarker[1] = false;
          for (int i = 2; i <= n; i++) {
              if (primeMarker[i]) {
                  // we start from 2*i because i*1 must be prime
                  for (int j = 2 * i; j <= n; j += i) {
                      primeMarker[j] = false;
                  }
              }
          }
          return primeMarker;
      }
  
      private void tr(Object... o) {
          if (!oj) System.out.println(Arrays.deepToString(o));
      }
  
      class Pair<F, S> {
          private F first;
          private S second;
  
          Pair(F first, S second) {
              this.first = first;
              this.second = second;
          }
  
          public F getFirst() {
              return first;
          }
  
          public S getSecond() {
              return second;
          }
  
          @Override
          public String toString() {
              return "Pair{" +
                      "first=" + first +
                      ", second=" + second +
                      '}';
          }
  
          @Override
          public boolean equals(Object o) {
              if (this == o) return true;
              if (o == null || getClass() != o.getClass()) return false;
              Pair<?, ?> pair = (Pair<?, ?>) o;
              return Objects.equals(first, pair.first) && Objects.equals(second, pair.second);
          }
      }
  
      public static void main(String[] args) throws IOException {
          new Main().run();
      }
  
      public void run() throws IOException {
          if (oj) {
              rd = new Reader();
              wr = new FastWriter(System.out);
          } else {
              File input = new File("input.txt");
              File output = new File("output.txt");
              if (input.exists() && output.exists()) {
                  rd = new Reader(input.getPath());
                  wr = new FastWriter(output.getPath());
              } else {
                  rd = new Reader();
                  wr = new FastWriter(System.out);
                  oj = true;
              }
          }
          long s = System.currentTimeMillis();
          solve();
          wr.flush();
          tr(System.currentTimeMillis() - s + "ms");
      }
  
      /***************************************************************************************************************************
       *********************************************************** MAIN CODE ******************************************************
       ****************************************************************************************************************************/
  
      public void solve() throws IOException {
          int t = ni();
          while (t-- > 0) {
              go();
          }
      }
  
      /********************************************************* MAIN LOGIC HERE ****************************************************/
  
      public void go() throws IOException {
          int n=ni();
          String sup=ns();
          String[] arr=sup.split(" ");
  
          String s=arr[0];
          for(int i=1;i<n-2;i++){
              if(s.charAt(s.length()-1)==arr[i].charAt(0)){
                  s+=arr[i].charAt(1);
              }else {
                  s+=arr[i];
              }
  
          }
          int rem=n-s.length();
          for(int i=0;i<rem;i++){
              s+='a';
          }
          wr.println(s);
  
      }
  }
  
  