import java.io.*;
import java.util.*;
/**
 * Clase que permite la entrada de elementos a un programa
 * a través del teclado y la salida en la pantalla.
 * Objetivo: Facilitar la entrada/salida de datos.
 * @version:    Mayo 2003
 */
public class InOut {
    private static InputStreamReader is = new InputStreamReader( System.in );
    private static BufferedReader br = new BufferedReader( is );
    private StringTokenizer st;

    /*
     * Método que permite obtener el siguiente elemento de una línea leída
     */
    private StringTokenizer getToken() throws IOException {
       String s = br.readLine();
       return new StringTokenizer(s);
    }

    /**
     * Método que permite leer un valor booleano
     * @return boolean - dato leido.
     */
    public boolean readBoolean() {
       try {
          st = getToken();
          return new Boolean(st.nextToken()).booleanValue();
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readBoolean");
          return false;
       }
    }
    /**
     * Método que permite leer un valor de tipo byte
     * @return byte - dato leido.
     */
    public byte readByte() {
       try {
         st = getToken();
         return Byte.parseByte(st.nextToken());
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readByte");
          return 0;
       }
    }

    /**
     * Método que permite leer un valor de tipo short
     * @return short - dato leido.
     */
    public short readShort() {
       try {
         st = getToken();
         return Short.parseShort(st.nextToken());
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readShort");
          return 0;
       }
    }

    /**
     * Método que permite leer un valor de tipo entero
     * @return int - dato leido.
     */
    public int readInt() {
       try {
         st = getToken();
         return Integer.parseInt(st.nextToken());
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readInt");
          return 0;
       }
    }

    /**
     * Método que permite leer un valor de tipo entero grande
     * @return long - dato leido.
     */
    public long readLong() {
       try {
         st = getToken();
         return Long.parseLong(st.nextToken());
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readFloat");
          return 0L;
       }
    }

    /**
     * Método que permite leer un valor de tipo float
     * @return float - dato leido.
     */
    public float readFloat() {
       try {
         st = getToken();
         return new Float(st.nextToken()).floatValue();
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readFloat");
          return 0.0F;
       }
    }

    /**
     * Método que permite leer un valor de tipo double
     * @return double - dato leido.
     */
    public double readDouble() {
       try {
         st = getToken();
         return new Double(st.nextToken()).doubleValue();
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readDouble");
          return 0.0;
       }
    }

    /**
     * Método que permite leer un valor de tipo char
     * @return char - dato leido.
     */
    public char readChar() {
       try {
         String s = br.readLine();
         return s.charAt(0);
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readChar");
          return 0;
       }
    }

    /**
     * Método que permite leer un valor de tipo String
     * @return String - dato leido.
     */
    public String readString() {
       try {
         return br.readLine();
       } catch (IOException ioe) {
          System.err.println("IO Exception in InOut.readString");
          return "";
       }
    }
    /**
     * Método que permite leer un valor de tipo String del tipo especificado
     * @param size - cantidad de caracteres de la cadena que se leerá
     * @return short - dato leido.
     */
    public String readString(int size) {
	try {
	    return br.readLine().substring(0,size);
	} catch (IOException ioe) {
	    System.err.println("IO Exception in InOut.readString");
	    return "";
	}
    }

    /**
     * Método que permite escribir un valor de tipo Object.
     * @param objeto - objeto que se imprimirá
     */
    public void print(Object objeto) {
	System.out.print(objeto.toString());
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo Object y salta de línea.
     * @param objeto - objeto que se imprimirá
     */
    public void println(Object objeto) {
	System.out.println(objeto.toString());
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo entero.
     * @param i - entero que se imprimirá
     */
    public void print(int i) {
	System.out.print(i);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo entero y salta de línea.
     * @param i - entero que se imprimirá
     */
    public void println(int i) {
	System.out.println(i);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo caracter.
     * @param c - caracter que se imprimirá
     */
    public void print(char c) {
	System.out.print(c);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo caracter y salta de línea.
     * @param c - caracter que se imprimirá
     */
    public void println(char c) {
	System.out.println(c);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo real doble.
     * @param d - número que se imprimirá
     */
    public void print(double d) {
	System.out.print(d);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo real doble y salta de línea.
     * @param d - número que se imprimirá
     */
    public void println(double d) {
	System.out.println(d);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo real (float).
     * @param f - número que se imprimirá
     */
    public void print(float f) {
	System.out.print(f);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo real (float) y salta de línea.
     * @param f - número que se imprimirá
     */
    public void println(float f) {
	System.out.println(f);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo entero grande.
     * @param l - número que se imprimirá
     */
    public void print(long l) {
	System.out.print(l);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo entero grande y salta de línea.
     * @param l - número que se imprimirá
     */
    public void println(long l) {
	System.out.println(l);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo byte.
     * @param b - byte que se imprimirá
     */
    public void print(byte b) {
	System.out.print(b);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo byte y salta de línea.
     * @param b - byte que se imprimirá
     */
    public void println(byte b) {
	System.out.println(b);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo short.
     * @param s - short que se imprimirá
     */
    public void print(short s) {
	System.out.print(s);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo short y salta de línea.
     * @param s - short que se imprimirá
     */
    public void println(short s) {
	System.out.println(s);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo Booleano.
     * @param b - Booleano que se imprimirá
     */
    public void print(boolean b) {
	System.out.print(b);
	System.out.flush();
    }

    /**
     * Método que permite escribir un valor de tipo Booleano y salta de línea.
     * @param b - Booleano que se imprimirá
     */
    public void println(boolean b) {
	System.out.println(b);
	System.out.flush();
    }
}