      import java.io.*;

      public class EasyReader

      {

      protected String myFileName;

      protected BufferedReader myInFile;

      protected int myErrorFlags = 0;

      protected static final int OPENERROR = 0x0001;


      protected static final int CLOSEERROR = 0x0002;


      protected static final int READERROR = 0x0004;

      protected static final int EOF =	0x0100;


      /**

      * Constructor. Prepa	res console (System.in) for 	reading

      */

      public EasyReader()

      {

      myFileName = null;

      myErrorFlags = 0;

      myInFile = new BufferedReader(

      new InputStreamReader(System.in), 128);

      }


      /**

      * Constructor. opens a file for reading

      * @param fileName th	e name or pathname of the fi	le

      */

      public EasyReader(String fileName)

      {

      myFileName = fileName;

      myErrorFlags = 0;

      try

      {

      myInFile = new BufferedReader(new FileReader(fileName), 1024);

      }

      catch (FileNotFoundException e)

      {

      myErrorFlags |= OPENERROR;

      myFileName = null;

      }

      }


      /**

      * Closes the file

      */

      public void close()

      {

      if (myFileName == null)

      return;

      try

      {

      myInFile.close();

      }

      catch (IOException e)

      {

      System.err.println("	Error closing " + myFileName	+ "\n");

      myErrorFlags |= CLOSEERROR;

      }

      }


      /**

      * Checks the status of the file

      * @return true if en	error occurred opening or r	eading the file,

      * false otherwise

      */

      public boolean bad()

      {

      return myErrorFlags != 0;

      }


      /**

      * Checks the EOF status of the file

      * @return true if EOF was encoun	tered in the previous read

      * operation, false otherwise

      */

      public boolean eof()

      {

      return (myErrorFlags & EOF) != 0;

      }


      private boolean ready() throws IOException


      {

      return myFileName == null || myInFile.ready();

      }


      /**

      * Reads the next cha	racter from a file (any char	acter including

      * a space or a newline character).

      * @return character read or null character

      * (Unicode 0) if try	ing to read beyond the EOF


      */

      public char readChar()

      {

      char ch = '\u0000';


      try

      {

      if (ready())

      {

      ch = (char)myInFile.read();

      }

      }

      catch (IOException e)

      {

      if (myFileName != null)

      System.err.println("Error readin	g " + myFileName + "\n");

      myErrorFlags |= READERROR;

      }


      if (ch == '\u0000')

      myErrorFlags |= EOF;


      return ch;

      }


      /**

      * Reads from the cur	rent position in the file up	to and including

      * the next newline character. Th	e newline character is thrown away

      * @return the read string (exclu	ding the newline character) or

      * null if trying to read beyond the EOF

      */

      public String readLine()

      {

      String s = null;


      try

      {

      s = myInFile.readLine();

      }

      catch (IOException e)

      {

      if (myFileName != null)

      System.err.println("	Error reading " + myFileName	+ "\n");

      myErrorFlags |= READERROR;

      }


      if (s == null)

      myErrorFlags |= EOF;

      return s;

      }


      /**

      * Skips whitespace a	nd reads the next word (a st	ring of consecutive

      * non-whitespace characters (up 	to but excluding the next space,

      * newline, etc.)

      * @return the read string or nul	l if trying to read beyond the EOF

      */

      public String readWord()

      {

      StringBuffer buffer = new StringBuffer(128);


      char ch = ' ';

      int count = 0;

      String s = null;


      try

      {

      while (ready() && Character.isWhitespace(ch))


      ch = (char)myInFile.read();

      while (ready() && !Character.isWhitespace(ch))


      {

      count++;

      buffer.append(ch);

      myInFile.mark(1);

      ch = (char)myInFile.read();

      };


      if (count > 0)

      {

      myInFile.reset();

      s = buffer.toString();

      }

      else

      {

      myErrorFlags |= EOF;

      }

      }


      catch (IOException e)

      {

      if (myFileName != null)

      System.err.println("	Error reading " + myFileName	+ "\n");

      myErrorFlags |= READERROR;

      }


      return s;

      }


      /**

      * Reads the next int	eger (without validating its	format)

      * @return the integer read or 0 	if trying to read beyond the EOF

      */

      public int readInt()

      {

      String s = readWord();

      if (s != null)

      return Integer.parseInt(s);

      else

      return 0;

      }


      /**

      * Reads the next dou	ble (without validating its 	format)

      * @return the number	read or 0 if trying to read	beyond the EOF

      */

      public double readDouble()

      {

      String s = readWord();

      if (s != null)

      return Double.parseDouble(s);

      // in Java 1, use: return Double	.valueOf(s).doubleValue();

      else

      return 0.0;

      }

      }
