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

public class jardakovezes {

    public static void main(String[] args) throws Exception {
        IO io = new IO();

        /* Példa beolvasás és kiírás:
        int N = io.nextInt();
        String S = io.next();

        io.write(N);
        io.write(" ");
        io.writeLn(S);
        */

        io.close();
    }

}

/**
 * A beolvasás és kiíratás gyorsabb megvalósítását teszik lehetővé az osztály
 * műveletei.
 * Beolvasáshoz használható műveletek:
 *  nextInt(), nextLong(), next(): a soron következő int, long, illetve String
 *   érték beolvasása
 *   (a szóköz, sorvége, tabulátor, kocsivissza karakterek átugrásával)
 *  getChar(): a következő karakter (lehet szóköz, sorvége, stb. is!) beolvasása
 *  getLine(): beolvasás az aktuális karaktertől a következő sorvége karakterig
 *   (a sorvéget nem adja vissza!)
 * Kiíráshoz használható műveletek:
 *  write(int), write(long), write(String): egy int, long, vagy String típusú
 *   érték kiírása
 *  writeLn(int), writeLn(long), writeLn(String): egy int, long, vagy String
 *   típusú érték és egy sorvége karakter kiírása
 */
class IO implements Closeable {

    private static final int BUF_SIZE = 4096;

    private final byte[] buf = new byte[BUF_SIZE];
    private int pointer = 0;
    private int available = 0;

    private final InputStream in;
    private final OutputStream out;

    public IO() {
        in = System.in;
        out = System.out;
    }

    @Override
    public void close() throws IOException {
        in.close();
        out.close();
    }

    /**
     * A művelet a standard inputról olvas. Az aktuális pozíciótól olvasva átlépi a
     * szóköz, sorvége, tabulátor és kocsivissza karaktareket.
     * Ettől a pozíciótól a számjegy karaktereket olvassa be az első nem-számjegy
     * karakterig, és a szám értékét adja vissza int értékként.
     * Ha az első ilyen karakter nem számjegy, akkor a 0 értéket adja (nem
     * keletkezik megszakítás).
     * A beolvasás után az aktuális pozíció az első nem-számjegy karakter pozíciója
     * lesz.
     */
    public int nextInt() throws InputMismatchException, IOException {
        while (!isEOF() && isWhiteSpace(peekChar())) {
            popChar();
        }
        int sign = popSign();

        throwIfEOF();

        int num = 0;
        int c;
        for (;;) {
            if (pointer >= available && available >= 0) {
                available = in.read(buf, 0, BUF_SIZE);
                pointer = 0;
            }
            if (available == -1) {
                c = -1;
            } else {
                c = buf[pointer];
            }
            if ('0' <= c && c <= '9') {
                num = num * 10 + (c - '0');
                pointer++;
            } else {
                break;
            }
        }
        return sign * num;
    }

    /**
     * A művelet a standard inputról olvas. Az aktuális pozíciótól olvasva átlépi a
     * szóköz, sorvége, tabulátor és kocsivissza karaktareket.
     * Ettől a pozíciótól a számjegy karaktereket olvassa be az első nem-számjegy
     * karakterig, és a szám értékét adja vissza long értékként.
     * Ha az első ilyen karakter nem számjegy, akkor a 0 értéket adja (nem
     * keletkezik megszakítás).
     * A beolvasás után az aktuális pozíció az első nem-számjegy karakter pozíciója
     * lesz.
     */
    public long nextLong() throws InputMismatchException, IOException {
        while (!isEOF() && isWhiteSpace(peekChar())) {
            popChar();
        }
        int sign = popSign();

        throwIfEOF();

        long num = 0;
        int c;
        for (;;) {
            if (pointer >= available && available >= 0) {
                available = in.read(buf, 0, BUF_SIZE);
                pointer = 0;
            }
            if (available == -1) {
                c = -1;
            } else {
                c = buf[pointer];
            }
            if ('0' <= c && c <= '9') {
                num = num * 10 + (c - '0');
                pointer++;
            } else {
                break;
            }
        }
        return sign * num;
    }

    /**
     * A művelet a standard inputról olvas. Az aktuális pozíciótól olvasva átlépi a
     * szóköz, sorvége, tabulátor és kocsivissza karaktareket.
     * Ettől a pozíciótól az első szóköz vagy sorvége vagy tabulátor vagy
     * kocsivissza karakterig terjedő szövegrészt olvassa be és adja vissza String
     * értékként.
     * A beolvasás után az aktuális pozíció az első szóköz vagy sorvége vagy
     * tabulátor vagy kocsivissza karakter pozíciója lesz.
     */
    public String next() throws InputMismatchException, IOException {
        popWhitespace();
        StringBuilder sb = new StringBuilder();

        throwIfEOF();

        int c;
        while (!isWhiteSpace(c = peekChar())) {
            sb.append((char) c);
            popChar();
        }
        return sb.toString();
    }

    /**
     * A művelet a standard inputról olvas. Az aktuális pozíciótól az első sorvége
     * karakterig teljedő szövegrészt olvassa be és adja vissza String értékként. A
     * sorvége karakter nem kerül visszaadásra.
     * A művelet végén az aktuális pozíció az első sorvége karaktert követő pozíció
     * lesz.
     */
    public String getLine() throws InputMismatchException, IOException {
        throwIfEOF();

        StringBuilder sb = new StringBuilder();
        int c;
        while (!isEOF() && (c = peekChar()) != '\n') {
            popChar();
            sb.append((char) c);
        }
        if (peekChar() == '\n') {
            popChar();
        }
        return sb.toString();
    }

    /**
     * A művelet a standard inputról olvassa az aktuális pozíción lévő karaktert
     * (lehet szóköz, sorvége, tabulátor és kocsivissza karakter is), majd a
     * következő pozícióra lép.
     */
    public char getChar() throws InputMismatchException, IOException {
        throwIfEOF();
        char c = (char) peekChar();
        popChar();
        return c;
    }

    /**
     * Az x karaktert írja ki a standard outputra.
     */
    public void write(char x) throws IOException {
        out.write(x);
    }

    /**
     * Az x int típusú egész kifejezés értékét írja ki a standard outputra.
     */
    public void write(int x) throws IOException {
        out.write(Integer.toString(x).getBytes());
    }

    /**
     * Az x int típusú egész kifejezés értékét írja ki a standard outputra, majd ír
     * egy sorvéget.
     */
    public void writeLn(int x) throws IOException {
        out.write(Integer.toString(x).getBytes());
        out.write('\n');
        out.flush();
    }

    /**
     * Az x long típusú egész kifejezés értékét írja ki a standard outputra.
     */
    public void write(long x) throws IOException {
        out.write(Long.toString(x).getBytes());
    }

    /**
     * Az x long típusú egész kifejezés értékét írja ki a standard outputra, majd ír
     * egy sorvéget.
     */
    public void writeLn(long x) throws IOException {
        out.write(Long.toString(x).getBytes());
        out.write('\n');
        out.flush();
    }

    /**
     * Az s string (kifejezés) értékét írja ki a standard outputra.
     */
    public void write(String s) throws IOException {
        out.write(s.getBytes());
    }

    /**
     * Az s string (kifejezés) értékét írja ki a standard outputra, majd ír egy
     * sorvéget.
     */
    public void writeLn(String s) throws IOException {
        out.write(s.getBytes());
        out.write('\n');
        out.flush();
    }

    private void throwIfEOF() throws InputMismatchException, IOException {
        if (isEOF()) {
            throw new InputMismatchException("EOF");
        }
    }

    private boolean isEOF() throws IOException {
        if (pointer < available) {
            return false;
        } else if (available >= 0) {
            available = in.read(buf, 0, BUF_SIZE);
            pointer = 0;
            return available < 0;
        } else {
            return true;
        }
    }

    private void popChar() throws IOException {
        loadBufferIfNeeded();
        ++pointer;
    }

    private int peekChar() throws IOException {
        loadBufferIfNeeded();
        if (available == -1) {
            return -1;
        }
        return buf[pointer];
    }

    private void loadBufferIfNeeded() throws IOException {
        if (pointer < available || available < 0) {
            return;
        }
        available = in.read(buf, 0, BUF_SIZE);
        pointer = 0;
    }

    private static boolean isWhiteSpace(int n) {
        return n == ' ' || n == '\n' || n == '\r' || n == '\t' || n == -1;
    }

    private void popWhitespace() throws IOException {
        while (!isEOF() && isWhiteSpace(peekChar())) {
            popChar();
        }
    }

    private int popSign() throws IOException {
        if (peekChar() == '-') {
            popChar();
            return -1;
        } else {
            return +1;
        }
    }
}