description: You are given a string s of length n consisting of characters a and/or b.
  
  Let \operatorname{AB}(s) be the number of occurrences of string ab in s as a substring. Analogically, \operatorname{BA}(s) is the number of occurrences of ba in s as a substring.
  
  In one step, you can choose any index i and replace s_i with character a or b.
  
  What is the minimum number of steps you need to make to achieve \operatorname{AB}(s) = \operatorname{BA}(s)?
  
  Reminder:
  
  The number of occurrences of string d in s as substring is the number of indices i (1 ≤ i ≤ |s| - |d| + 1) such that substring s_i s_{i + 1} ... s_{i + |d| - 1} is equal to d. For example, \operatorname{AB}(aabbbabaa) = 2 since there are two indices i: i = 2 where aabbbabaa and i = 6 where aabbbabaa.
  
  Input
  
  Each test contains multiple test cases. The first line contains the number of test cases t (1 ≤ t ≤ 1000). Description of the test cases follows.
  
  The first and only line of each test case contains a single string s (1 ≤ |s| ≤ 100, where |s| is the length of the string s), consisting only of characters a and/or b.
  
  Output
  
  For each test case, print the resulting string s with \operatorname{AB}(s) = \operatorname{BA}(s) you'll get making the minimum number of steps.
  
  If there are multiple answers, print any of them.
  
  Example
  
  Input
  
  
  4
  b
  aabbbabaa
  abbb
  abbaab
  
  
  Output
  
  
  b
  aabbbabaa
  bbbb
  abbaaa
  
  Note
  
  In the first test case, both \operatorname{AB}(s) = 0 and \operatorname{BA}(s) = 0 (there are no occurrences of ab (ba) in b), so can leave s untouched.
  
  In the second test case, \operatorname{AB}(s) = 2 and \operatorname{BA}(s) = 2, so you can leave s untouched. 
  
  In the third test case, \operatorname{AB}(s) = 1 and \operatorname{BA}(s) = 0. For example, we can change s_1 to b and make both values zero.
  
  In the fourth test case, \operatorname{AB}(s) = 2 and \operatorname{BA}(s) = 1. For example, we can change s_6 to a and make both values equal to 1.
solution: # Sujith
  from sys import stdin,stdout,setrecursionlimit
  from io import BytesIO, IOBase
  # from heapq import heappush as push,heappop as hp,heapify as h
  # from math import gcd,floor,sqrt,ceil
  # from collections import Counter,deque as dq
  # from itertools import accumulate as acc,permutations as perm
  # from bisect import bisect_left as bl,bisect_right as br,bisect as bis
  
  setrecursionlimit(10000)
  
  class FastIO(IOBase):
      newlines = 0
  
      def __init__(self, file):
          import os
          self.os = os
          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
          self.BUFSIZE = 8192
  
      def read(self):
          while True:
              a = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
              if not a:
                  break
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(a), self.buffer.seek(ptr)
          self.newlines = 0
          return self.buffer.read()
  
      def readline(self):
          while self.newlines == 0:
              a = self.os.read(self._fd, max(self.os.fstat(self._fd).st_size, self.BUFSIZE))
              self.newlines = a.count(b"\n") + (not a)
              ptr = self.buffer.tell()
              self.buffer.seek(0, 2), self.buffer.write(a), self.buffer.seek(ptr)
          self.newlines -= 1
          return self.buffer.readline()
  
      def flush(self):
          if self.writable:
              self.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")
  
  
  stdin, stdout = IOWrapper(stdin), IOWrapper(stdout)
  input = lambda: stdin.readline().rstrip("\r\n")
  
  # inf = float('inf')
  # ninf = float('-inf')
  # abc = 'abcdefghijklmnopqrstuvwxyz'
  inp = lambda: int(input())
  st = lambda: input().strip()
  jn = lambda x,l: x.join(map(str,l))
  int_arr = lambda : list(map(int,input().strip().split()))
  str_arr = lambda :list(map(str,input().split()))
  get_str = lambda : map(str,input().strip().split())
  get_int = lambda: map(int,input().strip().split())
  get_float = lambda : map(float,input().strip().split())
  
  mod = 1000000007
  
  #main()
  for _ in range(inp()):
      s = st()
  
      ab = s.count('ab')
      ba = s.count('ba')
      lst = list(s)
  
      if ab == ba:
          print(s)
      else:
          for i in range(len(s)):
              lst[i] = 'a'
              s1 = ''.join(lst)
              if s1.count('ab') == s1.count('ba'):
                  print(s1)
                  break
              lst[i] = 'b'
              s2 = ''.join(lst)
              if s2.count('ab') == s2.count('ba'):
                  print(s2)
                  break
          
  
  
  
  
  
  