Polycarp is writing the prototype of a graphic editor. He has already made up his mind that the basic image transformations in his editor will be: rotate the image 90 degrees clockwise, flip the image horizontally (symmetry relative to the vertical line, that is, the right part of the image moves to the left, and vice versa) and zooming on the image. He is sure that that there is a large number of transformations that can be expressed through these three.

He has recently stopped implementing all three transformations for monochrome images. To test this feature, he asked you to write a code that will consecutively perform three actions with a monochrome image: first it will rotate the image 90 degrees clockwise, then it will flip the image horizontally and finally, it will zoom in twice on the image (that is, it will double all the linear sizes).

Implement this feature to help Polycarp test his editor.

Input

The first line contains two integers, w and h (1 ≤ w, h ≤ 100) — the width and height of an image in pixels. The picture is given in h lines, each line contains w characters — each character encodes the color of the corresponding pixel of the image. The line consists only of characters "." and "*", as the image is monochrome.

Output

Print 2w lines, each containing 2h characters — the result of consecutive implementing of the three transformations, described above.

Examples

Input

3 2
.*.
.*.


Output

....
....
****
****
....
....


Input

9 20
**.......
****.....
******...
*******..
..******.
....****.
......***
*.....***
*********
*********
*********
*********
....**...
...****..
..******.
.********
****..***
***...***
**.....**
*.......*


Output

********......**********........********
********......**********........********
********........********......********..
********........********......********..
..********......********....********....
..********......********....********....
..********......********..********......
..********......********..********......
....********....****************........
....********....****************........
....********....****************........
....********....****************........
......******************..**********....
......******************..**********....
........****************....**********..
........****************....**********..
............************......**********
............************......**********
import java.io.*;
import java.util.*;

/**
 * @author master_j
 * @version 0.4
 * @since May 3, 2014
 */
public class Main {

    private void solve() throws IOException {
        int w = io.nI(), h = io.nI();
        io.wc(".*");
        boolean[][] map = new boolean[h][w];
        for (int i = 0; i < h; i++) {
            String s = io.nS();
            for (int j = 0; j < s.length(); j++)
                map[i][j] = s.charAt(j) == '*';
        }

        boolean[][] tmp = map;
        tmp = upsidedown(tmp);
        tmp = rotate(tmp);
        tmp = rastaraschting(tmp);

        trace(tmp);
    }//2.2250738585072012e-308

    void trace(boolean[][] map) {
        for (int i = 0; i < map.length; i++) {
            for (int j = 0; j < map[i].length; j++)
                io.w(map[i][j] ? '*' : '.');
            io.wln();
        }
    }

    boolean[][] rotate(boolean[][] map) {
        boolean[][] res = new boolean[map[0].length][map.length];
        for (int i = 0; i < res.length; i++)
            for (int j = 0; j < res[i].length; j++)
                res[i][j] = map[map.length - j - 1][i];
        return res;
    }

    boolean[][] upsidedown(boolean[][] map) {
        boolean[][] res = new boolean[map.length][map[0].length];
        for (int i = 0; i < map.length; i++)
            res[i] = map[map.length - i - 1].clone();
        return res;
    }

    boolean[][] rastaraschting(boolean[][] map) {//It's like Russian borscht but scale.
        boolean[][] res = new boolean[2 * map.length][2 * map[0].length];
        for (int i = 0; i < res.length; i++)
            for (int j = 0; j < res[i].length; j++)
                res[i][j] = map[i / 2][j / 2];
        return res;
    }

    public static void main(String[] args) throws IOException {
        IO.launchSolution(args);
    }

    Main(IO io) throws IOException {
        this.io = io;
        solve();
    }

    private final IO io;
}

class IO {
    static final String _localArg = "master_j";
    private static final String _problemName = "";
    private static final IO.Mode _inMode = Mode.STD_;
    private static final IO.Mode _outMode = Mode.STD_;
    private static final boolean _autoFlush = false;

    static enum Mode {STD_, _PUT_TXT, PROBNAME_}

    private final StreamTokenizer st;
    private final BufferedReader br;
    private final Reader reader;

    private final PrintWriter pw;
    private final Writer writer;

    static void launchSolution(String[] args) throws IOException {
        boolean local = (args.length == 1 && args[0].equals(IO._localArg));
        IO io = new IO(local);

        long nanoTime = 0;
        if (local) {
            nanoTime -= System.nanoTime();
            io.wln("<output>");
        }

        io.flush();
        new Main(io);
        io.flush();

        if(local){
            io.wln("</output>");
            nanoTime += System.nanoTime();
            final long D9 = 1000000000, D6 = 1000000, D3 = 1000;
            if(nanoTime >= D9)
                io.wf("%d.%d seconds\n", nanoTime/D9, nanoTime%D9);
            else if(nanoTime >= D6)
                io.wf("%d.%d millis\n", nanoTime/D6, nanoTime%D6);
            else if(nanoTime >= D3)
                io.wf("%d.%d micros\n", nanoTime/D3, nanoTime%D3);
            else
                io.wf("%d nanos\n", nanoTime);
        }

        io.close();
    }

    IO(boolean local) throws IOException {
        if(_inMode == Mode.PROBNAME_ || _outMode == Mode.PROBNAME_)
            if(_problemName.length() == 0)
                throw new IllegalStateException("You imbecile. Where's my <_problemName>?");

        if(_problemName.length() > 0)
            if(_inMode != Mode.PROBNAME_ && _outMode != Mode.PROBNAME_)
                throw new IllegalStateException("You imbecile. What's the <_problemName> for?");

        Locale.setDefault(Locale.US);

        if (local) {
            reader = new FileReader("input.txt");
            writer = new OutputStreamWriter(System.out);
        } else {
            switch (_inMode) {
                case STD_:
                    reader = new InputStreamReader(System.in);
                    break;
                case PROBNAME_:
                    reader = new FileReader(_problemName + ".in");
                    break;
                case _PUT_TXT:
                    reader = new FileReader("input.txt");
                    break;
                default:
                    throw new NullPointerException("You imbecile. Gimme _inMode.");
            }
            switch (_outMode) {
                case STD_:
                    writer = new OutputStreamWriter(System.out);
                    break;
                case PROBNAME_:
                    writer = new FileWriter(_problemName + ".out");
                    break;
                case _PUT_TXT:
                    writer = new FileWriter("output.txt");
                    break;
                default:
                    throw new NullPointerException("You imbecile. Gimme _outMode.");
            }
        }

        br = new BufferedReader(reader);
        st = new StreamTokenizer(br);

        pw = new PrintWriter(writer, _autoFlush);

        if(local && _autoFlush)
            wln("Note: auto-flush is on.");
    }

    void wln()          {pw.println(); }
    void wln(boolean x) {pw.println(x);}
    void wln(char x)    {pw.println(x);}
    void wln(char x[])  {pw.println(x);}
    void wln(double x)  {pw.println(x);}
    void wln(float x)   {pw.println(x);}
    void wln(int x)     {pw.println(x);}
    void wln(long x)    {pw.println(x);}
    void wln(Object x)  {pw.println(x);}
    void wln(String x)  {pw.println(x);}

    void wf(String f, Object...o){pw.printf(f, o);}

    void w(boolean x)   {pw.print(x);}
    void w(char x)      {pw.print(x);}
    void w(char x[])    {pw.print(x);}
    void w(double x)    {pw.print(x);}
    void w(float x)     {pw.print(x);}
    void w(int x)       {pw.print(x);}
    void w(long x)      {pw.print(x);}
    void w(Object x)    {pw.print(x);}
    void w(String x)    {pw.print(x);}

    int nI() throws IOException    {st.nextToken(); return (int)st.nval;}
    double nD() throws IOException {st.nextToken(); return st.nval;}
    float nF() throws IOException  {st.nextToken(); return (float)st.nval;}
    long nL() throws IOException   {st.nextToken(); return (long)st.nval;}
    String nS() throws IOException {st.nextToken(); return st.sval;}

    void wc(String x){ wc(x.toCharArray()); }
    void wc(char c1, char c2){for(char c = c1; c<=c2; c++)wc(c);}
    void wc(char x[]){
        for(char c : x)
            wc(c);
    }
    void wc(char x){st.ordinaryChar(x); st.wordChars(x, x);}

    public boolean eof() {return st.ttype == StreamTokenizer.TT_EOF;}
    public boolean eol() {return st.ttype == StreamTokenizer.TT_EOL;}

    void flush(){pw.flush();}
    void close() throws IOException{reader.close(); br.close(); flush(); pw.close();}
}