Problem: Let's say string s has period k if s_i = s_{i + k} for all i from 1 to |s| - k (|s| means length of string s) and k is the minimum positive integer with this property.

Some examples of a period: for s="0101" the period is k=2, for s="0000" the period is k=1, for s="010" the period is k=2, for s="0011" the period is k=4.

You are given string t consisting only of 0's and 1's and you need to find such string s that:

  1. String s consists only of 0's and 1's; 
  2. The length of s doesn't exceed 2 ⋅ |t|; 
  3. String t is a subsequence of string s; 
  4. String s has smallest possible period among all strings that meet conditions 1—3. 



Let us recall that t is a subsequence of s if t can be derived from s by deleting zero or more elements (any) without changing the order of the remaining elements. For example, t="011" is a subsequence of s="10101".

Input

The first line contains single integer T (1 ≤ T ≤ 100) — the number of test cases.

Next T lines contain test cases — one per line. Each line contains string t (1 ≤ |t| ≤ 100) consisting only of 0's and 1's.

Output

Print one string for each test case — string s you needed to find. If there are multiple solutions print any one of them.

Example

Input


4
00
01
111
110


Output


00
01
11111
1010

Note

In the first and second test cases, s = t since it's already one of the optimal solutions. Answers have periods equal to 1 and 2, respectively.

In the third test case, there are shorter optimal solutions, but it's okay since we don't need to minimize the string s. String s has period equal to 1.

Solution (in JAVA):

Solution:
import java.util.*;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;

public class a{
   static char[] count;
   // static int[] count1;
   static int[] arr;
   static char[] c;
   static long[] darr;
   // static int x;
   static long maxl;
   // static long minl;
   static int mx = (int)1e6;
   static long mod = 998244353l;
   // static int minl = -1;
   static int n;
   static long a;
   static long b;
   // static long c;
   static long d;
   static int x;
   static long y;
   static int m;
   static long k;
   static String str;
   static Set<Integer> set;
   static Set<Integer> list;
   static Map<Integer,List<Integer>> map;
   static StringBuilder sb;

   // public static int log(long n){
   //     if(n == 0)
   //         return 0;

   //     if(n == 1)
   //         return 0;
   //     if(n == 2)
   //         return 1;
   //     double num = Math.log(n);
   //     double den = Math.log(2);
   //     if(den == 0)
   //         return 0;
   //     return (int)(num/den);
   // }

   // public static void swap(int i,int j){
   //     long temp = arr[j];
   //     arr[j] = arr[i];
   //     arr[i] = temp;
   // }

   static class FastScanner {
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        StringTokenizer st=new StringTokenizer("");
        String next() {
            while (!st.hasMoreTokens())
                try {
                    st=new StringTokenizer(br.readLine());
                } catch (IOException e) {
                    e.printStackTrace();
                }
            return st.nextToken();
        }
        
        int nextInt() {
            return Integer.parseInt(next());
        }
        int[] readArray(int n) {
            int[] a=new int[n];
            for (int i=0; i<n; i++) a[i]=nextInt();
            return a;
        }
        long nextLong() {
            return Long.parseLong(next());
        }
    }

   public static void solve(){

        boolean flag = false;
        for(int i = 0 ; i < n-1 ; i++){
            if(c[i] != c[i+1]){
                flag = true;
                break;
            }
        }

        sb = new StringBuilder();

        if(!flag){
            for(int i = 0;  i < n ; i++)
                sb.append(c[i]);
        }
        else{
            sb.append(c[0]);
            for(int i = 1; i < 2*n ; i++){
                if(i%2 == 0){
                    sb.append(c[0]);
                }
                else
                    sb.append(1-(c[0]-'0'));
            }
        }
        System.out.println(sb);
        
   }

   public static void main(String[] args) {

      FastScanner sc = new FastScanner();

      int t = sc.nextInt();
      while(t > 0){
         // set = new HashSet<>();
         // map = new HashMap<>();
//         a = sc.nextLong();
//         b = sc.nextLong();
//         c = sc.nextLong();
//         d = sc.nextLong();

         // long x = sc.nextLong();

         // maxl = Integer.MIN_VALUE;


         // n = sc.nextInt();
         //k = sc.nextLong();
         // k = sc.nextInt();
         // // x = sc.nextInt();
         c = sc.next().toCharArray();
         n = c.length;

         // // // k = sc.nextInt();
         // arr = new int[n];
         // // // // // // darr = new char[n];

         //  for(int i = 0; i < n ; i++){
         //      arr[i] = sc.nextInt();
         //  }



         // darr = new long[n];
         // for(int i = 0; i < n ; i++){
         //     darr[i] = sc.nextLong();
         // }
         // boolean flag = false;
         // str = sc.next();

         // x = sc.nextInt();



         //System.out.println(solve()?"Yes":"No");
         solve();
         //System.out.println(solve());
         // sb = new StringBuilder();
         // sb.append(str);

         t -= 1;
      }



   }
}