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.io.*;
import java.util.*;

import static java.lang.Math.*;

public class Contest {
    public static class pair implements Comparable<pair> {
        int u;
        long val;

        public pair(int a, long value) {
            u = a;
            val = value;
        }

        @Override
        public int compareTo(pair p) {
            return Long.compare(val, p.val);
        }
    }

    static int n, m;
    static ArrayList<Integer>[] adj;
    static int dist[];
    static int parent[];
    static long inf = (long) 1e16;
    static int INF = (int) 1e9;

    public static int[] bfs(int s) {
        dist = new int[n];
        Arrays.fill(dist, -1);
        dist[s] = 0;
        Queue<Integer> q = new LinkedList<>();
        q.add(s);
        while (!q.isEmpty()) {
            int u = q.poll();
            for (int v : adj[u])
                if (dist[v] == -1) {
                    dist[v] = dist[u] + 1;
                    q.add(v);
                }
        }
        return dist;
    }

    public static long calc(long[] acc, int single, int Dbl) {
        if (single + Dbl > m) return inf;
        return acc[Dbl] + acc[single + Dbl];
    }

    public static boolean subset(TreeSet<Integer> small, TreeSet<Integer> big) {
        for (int x : small)
            if (!big.contains(x))
                return false;
        return true;
    }

    public static TreeSet<Integer> subset2(TreeSet<Integer> small, TreeSet<Integer> big) {
        TreeSet<Integer> ts = new TreeSet<>();
        for (int x : small)
            if (!big.contains(x))
                ts.add(x);
        return ts;
    }

    public static boolean CanBeStart(int x, TreeSet<Integer>[] Arr) {
        TreeSet<Integer> last = new TreeSet<>();
        for (int j = 0; j < n - 1; j++)
            if (Arr[j].contains(x)) {
                if (!subset(last, Arr[j]))
                    return false;
                last = Arr[j];
            }
        return true;
    }

    public static boolean check(TreeSet<Integer> sublist, ArrayList<Integer> arr) {
        int len = sublist.size(), n = arr.size();
        for (int i = 0; i < n - len + 1; i++) {
            boolean flag = true;
            for (int j = 0; j < len; j++)
                if (!sublist.contains(arr.get(i + j)))
                    flag = false;
            if (flag) return true;
        }
        return false;
    }

    public static boolean check(TreeSet<Integer>[] Arr, ArrayList<Integer> arr) {
        boolean ans = true;
        for (int i = 0; i < n - 1; i++)
            ans &= check(Arr[i], arr);
        return ans;
    }

    public static boolean alltrue(boolean[] arr) {
        for (boolean flag : arr)
            if (flag) return false;
        return true;
    }

    public static boolean sep(boolean[] arr) {
        boolean open = false;
        int cnt = 0;
        for (int i = 0; i < arr.length; i++)
            if (open) {
                if (!arr[i]) open = false;
            } else {
                if (arr[i]) {
                    open = true;
                    cnt++;
                }
            }
        return cnt <= 1;
    }


    static int[] dx = new int[]{-1, 1, 0, 0};
    static int[] dy = new int[]{0, 0, -1, 1};
    static boolean[][] Matrix, vis;

    static boolean valid(int i, int j) {
        return i != -1 && j != -1 && i != n && j != m && Matrix[i][j];
    }

    static void dfs2(int i, int j) {
        vis[i][j] = true;                        //mark as visited
        for (int k = 0; k < 4; ++k) {
            int x = i + dx[k], y = j + dy[k];
            if (valid(x, y) && !vis[x][y])
                dfs2(x, y);
        }
    }

    public static boolean isSimilar(char[] Arr, int s, int k) {
        for (int i = s; i < k - 1; i++) {
            if (Arr[i + 1] != Arr[i])
                return false;
        }
        return true;
    }

    public static int ciel(int d, int mod) {
        if (d % mod == 0)
            return d / mod;
        return d / mod + 1;
    }

    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) {
            String str=sc.next();
            if(isSimilar(str.toCharArray(), 0, str.length()))
                pw.println(str);
            else {
                for (int i = 0; i < 2 * str.length(); i++)
                    pw.print(i % 2 == 0 ? 0 : 1);
                pw.println();
            }
        }


        pw.close();

    }

    static class Scanner {
        StringTokenizer st;
        BufferedReader br;

        public Scanner(InputStream s) {
            br = new BufferedReader(new InputStreamReader(s));
        }

        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;
                }
            res += Long.parseLong(sb.toString()) / f;
            return res * (neg ? -1 : 1);
        }

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

    }
}