FOREIGN MODULE java_io;

IMPORT
    java_lang,
    java_net,
    java_security,
    java_util,
    sun_io,
    java_lang_reflect,
    java_lang_ref;

TYPE

  BufferedInputStream* = POINTER TO EXTENSIBLE RECORD (FilterInputStream)
                           buf! : POINTER TO ARRAY OF BYTE;
                           count! : INTEGER;
                           pos! : INTEGER;
                           markpos! : INTEGER;
                           marklimit! : INTEGER;
                         STATIC
                           PROCEDURE Init*(p0 : InputStream) : BufferedInputStream,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : InputStream;
                                           p1 : INTEGER) : BufferedInputStream,CONSTRUCTOR;
                         END;

  BufferedOutputStream* = POINTER TO EXTENSIBLE RECORD (FilterOutputStream)
                            buf! : POINTER TO ARRAY OF BYTE;
                            count! : INTEGER;
                          STATIC
                            PROCEDURE Init*(p0 : OutputStream) : BufferedOutputStream,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : OutputStream;
                                            p1 : INTEGER) : BufferedOutputStream,CONSTRUCTOR;
                          END;

  BufferedReader* = POINTER TO EXTENSIBLE RECORD (Reader)
                    STATIC
                      PROCEDURE Init*(p0 : Reader) : BufferedReader,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : Reader;
                                      p1 : INTEGER) : BufferedReader,CONSTRUCTOR;
                    END;

  BufferedWriter* = POINTER TO EXTENSIBLE RECORD (Writer)
                    STATIC
                      PROCEDURE Init*(p0 : Writer) : BufferedWriter,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : Writer;
                                      p1 : INTEGER) : BufferedWriter,CONSTRUCTOR;
                    END;

  ByteArrayInputStream* = POINTER TO EXTENSIBLE RECORD (InputStream)
                            buf! : POINTER TO ARRAY OF BYTE;
                            pos! : INTEGER;
                            mark! : INTEGER;
                            count! : INTEGER;
                          STATIC
                            PROCEDURE Init*(IN  p0 : ARRAY OF BYTE) : ByteArrayInputStream,CONSTRUCTOR;
                            PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                                p1 : INTEGER;
                                                p2 : INTEGER) : ByteArrayInputStream,CONSTRUCTOR;
                          END;

  ByteArrayOutputStream* = POINTER TO EXTENSIBLE RECORD (OutputStream)
                             buf! : POINTER TO ARRAY OF BYTE;
                             count! : INTEGER;
                           STATIC
                             PROCEDURE Init*() : ByteArrayOutputStream,CONSTRUCTOR;
                             PROCEDURE Init*(p0 : INTEGER) : ByteArrayOutputStream,CONSTRUCTOR;
                           END;

  CharArrayReader* = POINTER TO EXTENSIBLE RECORD (Reader)
                       buf! : POINTER TO ARRAY OF CHAR;
                       pos! : INTEGER;
                       markedPos! : INTEGER;
                       count! : INTEGER;
                     STATIC
                       PROCEDURE Init*(IN  p0 : ARRAY OF CHAR) : CharArrayReader,CONSTRUCTOR;
                       PROCEDURE Init*(IN  p0 : ARRAY OF CHAR;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : CharArrayReader,CONSTRUCTOR;
                     END;

  CharArrayWriter* = POINTER TO EXTENSIBLE RECORD (Writer)
                       buf! : POINTER TO ARRAY OF CHAR;
                       count! : INTEGER;
                     STATIC
                       PROCEDURE Init*() : CharArrayWriter,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : INTEGER) : CharArrayWriter,CONSTRUCTOR;
                     END;

  CharConversionException* = POINTER TO EXTENSIBLE RECORD (IOException)
                             STATIC
                               PROCEDURE Init*() : CharConversionException,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : java_lang.String) : CharConversionException,CONSTRUCTOR;
                             END;

  DataInput* = POINTER TO INTERFACE RECORD (java_lang.Object)
               END;

  DataInputStream* = POINTER TO EXTENSIBLE RECORD (FilterInputStream + DataInput)
                     STATIC
                       PROCEDURE Init*(p0 : InputStream) : DataInputStream,CONSTRUCTOR;
                       PROCEDURE readUTF*(p0 : DataInput) : java_lang.String;
                     END;

  DataOutput* = POINTER TO INTERFACE RECORD (java_lang.Object)
                END;

  DataOutputStream* = POINTER TO EXTENSIBLE RECORD (FilterOutputStream + DataOutput)
                        written! : INTEGER;
                      STATIC
                        PROCEDURE Init*(p0 : OutputStream) : DataOutputStream,CONSTRUCTOR;
                      END;

  EOFException* = POINTER TO EXTENSIBLE RECORD (IOException)
                  STATIC
                    PROCEDURE Init*() : EOFException,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : java_lang.String) : EOFException,CONSTRUCTOR;
                  END;

  Externalizable* = POINTER TO INTERFACE RECORD (java_lang.Object + Serializable)
                    END;

  File* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Serializable + java_lang.Comparable)
          STATIC
            separatorChar* : CHAR;
            separator* : java_lang.String;
            pathSeparatorChar* : CHAR;
            pathSeparator* : java_lang.String;
            PROCEDURE Init*(p0 : File;
                            p1 : java_lang.String) : File,CONSTRUCTOR;
            PROCEDURE Init*(p0 : java_lang.String) : File,CONSTRUCTOR;
            PROCEDURE Init*(p0 : java_lang.String;
                            p1 : java_lang.String) : File,CONSTRUCTOR;
            PROCEDURE createTempFile*(p0 : java_lang.String;
                                      p1 : java_lang.String) : File;
            PROCEDURE createTempFile*(p0 : java_lang.String;
                                      p1 : java_lang.String;
                                      p2 : File) : File;
            PROCEDURE listRoots*() : POINTER TO ARRAY OF File;
          END;

  FileDescriptor* = POINTER TO RECORD (java_lang.Object)
                    STATIC
                      in* : FileDescriptor;
                      out* : FileDescriptor;
                      err* : FileDescriptor;
                      PROCEDURE Init*() : FileDescriptor,CONSTRUCTOR;
                    END;

  FileFilter* = POINTER TO INTERFACE RECORD (java_lang.Object)
                END;

  FileInputStream* = POINTER TO EXTENSIBLE RECORD (InputStream)
                     STATIC
                       PROCEDURE Init*(p0 : File) : FileInputStream,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : FileDescriptor) : FileInputStream,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : java_lang.String) : FileInputStream,CONSTRUCTOR;
                     END;

  FilenameFilter* = POINTER TO INTERFACE RECORD (java_lang.Object)
                    END;

  FileNotFoundException* = POINTER TO EXTENSIBLE RECORD (IOException)
                           STATIC
                             PROCEDURE Init*() : FileNotFoundException,CONSTRUCTOR;
                             PROCEDURE Init*(p0 : java_lang.String) : FileNotFoundException,CONSTRUCTOR;
                           END;

  FileOutputStream* = POINTER TO EXTENSIBLE RECORD (OutputStream)
                      STATIC
                        PROCEDURE Init*(p0 : File) : FileOutputStream,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : FileDescriptor) : FileOutputStream,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : java_lang.String) : FileOutputStream,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : java_lang.String;
                                        p1 : BOOLEAN) : FileOutputStream,CONSTRUCTOR;
                      END;

  FilePermission* = POINTER TO RECORD (java_security.Permission + Serializable)
                    STATIC
                      PROCEDURE Init*(p0 : java_lang.String;
                                      p1 : java_lang.String) : FilePermission,CONSTRUCTOR;
                    END;

  FileReader* = POINTER TO EXTENSIBLE RECORD (InputStreamReader)
                STATIC
                  PROCEDURE Init*(p0 : File) : FileReader,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : FileDescriptor) : FileReader,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : java_lang.String) : FileReader,CONSTRUCTOR;
                END;

  FileWriter* = POINTER TO EXTENSIBLE RECORD (OutputStreamWriter)
                STATIC
                  PROCEDURE Init*(p0 : File) : FileWriter,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : FileDescriptor) : FileWriter,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : java_lang.String) : FileWriter,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : java_lang.String;
                                  p1 : BOOLEAN) : FileWriter,CONSTRUCTOR;
                END;

  FilterInputStream* = POINTER TO EXTENSIBLE RECORD (InputStream)
                         in! : InputStream;
                       STATIC
                         PROCEDURE Init!(p0 : InputStream) : FilterInputStream,CONSTRUCTOR;
                       END;

  FilterOutputStream* = POINTER TO EXTENSIBLE RECORD (OutputStream)
                          out! : OutputStream;
                        STATIC
                          PROCEDURE Init*(p0 : OutputStream) : FilterOutputStream,CONSTRUCTOR;
                        END;

  FilterReader* = POINTER TO ABSTRACT RECORD (Reader)
                    in! : Reader;
                  STATIC
                    PROCEDURE Init!(p0 : Reader) : FilterReader,CONSTRUCTOR;
                  END;

  FilterWriter* = POINTER TO ABSTRACT RECORD (Writer)
                    out! : Writer;
                  STATIC
                    PROCEDURE Init!(p0 : Writer) : FilterWriter,CONSTRUCTOR;
                  END;

  InputStream* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                 STATIC
                   PROCEDURE Init*() : InputStream,CONSTRUCTOR;
                 END;

  InputStreamReader* = POINTER TO EXTENSIBLE RECORD (Reader)
                       STATIC
                         PROCEDURE Init*(p0 : InputStream) : InputStreamReader,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : InputStream;
                                         p1 : java_lang.String) : InputStreamReader,CONSTRUCTOR;
                       END;

  InterruptedIOException* = POINTER TO EXTENSIBLE RECORD (IOException)
                              bytesTransferred* : INTEGER;
                            STATIC
                              PROCEDURE Init*() : InterruptedIOException,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : java_lang.String) : InterruptedIOException,CONSTRUCTOR;
                            END;

  InvalidClassException* = POINTER TO EXTENSIBLE RECORD (ObjectStreamException)
                             classname* : java_lang.String;
                           STATIC
                             PROCEDURE Init*(p0 : java_lang.String) : InvalidClassException,CONSTRUCTOR;
                             PROCEDURE Init*(p0 : java_lang.String;
                                             p1 : java_lang.String) : InvalidClassException,CONSTRUCTOR;
                           END;

  InvalidObjectException* = POINTER TO EXTENSIBLE RECORD (ObjectStreamException)
                            STATIC
                              PROCEDURE Init*(p0 : java_lang.String) : InvalidObjectException,CONSTRUCTOR;
                            END;

  IOException* = POINTER TO EXTENSIBLE RECORD (java_lang.Exception)
                 STATIC
                   PROCEDURE Init*() : IOException,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : java_lang.String) : IOException,CONSTRUCTOR;
                 END;

  LineNumberInputStream* = POINTER TO EXTENSIBLE RECORD (FilterInputStream)
                           STATIC
                             PROCEDURE Init*(p0 : InputStream) : LineNumberInputStream,CONSTRUCTOR;
                           END;

  LineNumberReader* = POINTER TO EXTENSIBLE RECORD (BufferedReader)
                      STATIC
                        PROCEDURE Init*(p0 : Reader) : LineNumberReader,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : Reader;
                                        p1 : INTEGER) : LineNumberReader,CONSTRUCTOR;
                      END;

  NotActiveException* = POINTER TO EXTENSIBLE RECORD (ObjectStreamException)
                        STATIC
                          PROCEDURE Init*() : NotActiveException,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : java_lang.String) : NotActiveException,CONSTRUCTOR;
                        END;

  NotSerializableException* = POINTER TO EXTENSIBLE RECORD (ObjectStreamException)
                              STATIC
                                PROCEDURE Init*() : NotSerializableException,CONSTRUCTOR;
                                PROCEDURE Init*(p0 : java_lang.String) : NotSerializableException,CONSTRUCTOR;
                              END;

  ObjectInput* = POINTER TO INTERFACE RECORD (java_lang.Object + DataInput)
                 END;

  ObjectInputStream$GetField* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                                STATIC
                                  PROCEDURE Init*() : ObjectInputStream$GetField,CONSTRUCTOR;
                                END;

  ObjectInputStream* = POINTER TO EXTENSIBLE RECORD (InputStream + ObjectInput + ObjectStreamConstants)
                       STATIC
                         PROCEDURE Init!() : ObjectInputStream,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : InputStream) : ObjectInputStream,CONSTRUCTOR;
                       END;

  ObjectInputValidation* = POINTER TO INTERFACE RECORD (java_lang.Object)
                           END;

  ObjectOutput* = POINTER TO INTERFACE RECORD (java_lang.Object + DataOutput)
                  END;

  ObjectOutputStream$PutField* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                                 STATIC
                                   PROCEDURE Init*() : ObjectOutputStream$PutField,CONSTRUCTOR;
                                 END;

  ObjectOutputStream* = POINTER TO EXTENSIBLE RECORD (OutputStream + ObjectOutput + ObjectStreamConstants)
                        STATIC
                          PROCEDURE Init!() : ObjectOutputStream,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : OutputStream) : ObjectOutputStream,CONSTRUCTOR;
                        END;

  ObjectStreamClass* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Serializable)
                       STATIC
                         NO_FIELDS* : POINTER TO ARRAY OF ObjectStreamField;
                         PROCEDURE lookup*(p0 : java_lang.Class) : ObjectStreamClass;
                       END;

  ObjectStreamConstants* = POINTER TO INTERFACE RECORD (java_lang.Object)
                           STATIC
                             STREAM_MAGIC* = -21267;
                             STREAM_VERSION* = 5;
                             TC_BASE* = 112;
                             TC_NULL* = 112;
                             TC_REFERENCE* = 113;
                             TC_CLASSDESC* = 114;
                             TC_OBJECT* = 115;
                             TC_STRING* = 116;
                             TC_ARRAY* = 117;
                             TC_CLASS* = 118;
                             TC_BLOCKDATA* = 119;
                             TC_ENDBLOCKDATA* = 120;
                             TC_RESET* = 121;
                             TC_BLOCKDATALONG* = 122;
                             TC_EXCEPTION* = 123;
                             TC_MAX* = 123;
                             baseWireHandle* = 8257536;
                             SC_WRITE_METHOD* = 1;
                             SC_BLOCK_DATA* = 8;
                             SC_SERIALIZABLE* = 2;
                             SC_EXTERNALIZABLE* = 4;
                             SUBSTITUTION_PERMISSION* : SerializablePermission;
                             SUBCLASS_IMPLEMENTATION_PERMISSION* : SerializablePermission;
                             PROTOCOL_VERSION_1* = 1;
                             PROTOCOL_VERSION_2* = 2;
                           END;

  ObjectStreamException* = POINTER TO ABSTRACT RECORD (IOException)
                           STATIC
                             PROCEDURE Init!() : ObjectStreamException,CONSTRUCTOR;
                             PROCEDURE Init!(p0 : java_lang.String) : ObjectStreamException,CONSTRUCTOR;
                           END;

  ObjectStreamField* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_lang.Comparable)
                       STATIC
                         PROCEDURE Init*(p0 : java_lang.String;
                                         p1 : java_lang.Class) : ObjectStreamField,CONSTRUCTOR;
                       END;

  OptionalDataException* = POINTER TO EXTENSIBLE RECORD (ObjectStreamException)
                             length* : INTEGER;
                             eof* : BOOLEAN;
                           END;

  OutputStream* = POINTER TO ABSTRACT RECORD (java_lang.Object)
                  STATIC
                    PROCEDURE Init*() : OutputStream,CONSTRUCTOR;
                  END;

  OutputStreamWriter* = POINTER TO EXTENSIBLE RECORD (Writer)
                        STATIC
                          PROCEDURE Init*(p0 : OutputStream) : OutputStreamWriter,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : OutputStream;
                                          p1 : java_lang.String) : OutputStreamWriter,CONSTRUCTOR;
                        END;

  PipedInputStream* = POINTER TO EXTENSIBLE RECORD (InputStream)
                        buffer! : POINTER TO ARRAY OF BYTE;
                        in! : INTEGER;
                        out! : INTEGER;
                      STATIC
                        PIPE_SIZE! = 1024;
                        PROCEDURE Init*() : PipedInputStream,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : PipedOutputStream) : PipedInputStream,CONSTRUCTOR;
                      END;

  PipedOutputStream* = POINTER TO EXTENSIBLE RECORD (OutputStream)
                       STATIC
                         PROCEDURE Init*() : PipedOutputStream,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : PipedInputStream) : PipedOutputStream,CONSTRUCTOR;
                       END;

  PipedReader* = POINTER TO EXTENSIBLE RECORD (Reader)
                 STATIC
                   PROCEDURE Init*() : PipedReader,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : PipedWriter) : PipedReader,CONSTRUCTOR;
                 END;

  PipedWriter* = POINTER TO EXTENSIBLE RECORD (Writer)
                 STATIC
                   PROCEDURE Init*() : PipedWriter,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : PipedReader) : PipedWriter,CONSTRUCTOR;
                 END;

  PrintStream* = POINTER TO EXTENSIBLE RECORD (FilterOutputStream)
                 STATIC
                   PROCEDURE Init*(p0 : OutputStream) : PrintStream,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : OutputStream;
                                   p1 : BOOLEAN) : PrintStream,CONSTRUCTOR;
                 END;

  PrintWriter* = POINTER TO EXTENSIBLE RECORD (Writer)
                   out! : Writer;
                 STATIC
                   PROCEDURE Init*(p0 : OutputStream) : PrintWriter,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : OutputStream;
                                   p1 : BOOLEAN) : PrintWriter,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : Writer) : PrintWriter,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : Writer;
                                   p1 : BOOLEAN) : PrintWriter,CONSTRUCTOR;
                 END;

  PushbackInputStream* = POINTER TO EXTENSIBLE RECORD (FilterInputStream)
                           buf! : POINTER TO ARRAY OF BYTE;
                           pos! : INTEGER;
                         STATIC
                           PROCEDURE Init*(p0 : InputStream) : PushbackInputStream,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : InputStream;
                                           p1 : INTEGER) : PushbackInputStream,CONSTRUCTOR;
                         END;

  PushbackReader* = POINTER TO EXTENSIBLE RECORD (FilterReader)
                    STATIC
                      PROCEDURE Init*(p0 : Reader) : PushbackReader,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : Reader;
                                      p1 : INTEGER) : PushbackReader,CONSTRUCTOR;
                    END;

  RandomAccessFile* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + DataOutput + DataInput)
                      STATIC
                        PROCEDURE Init*(p0 : File;
                                        p1 : java_lang.String) : RandomAccessFile,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : java_lang.String;
                                        p1 : java_lang.String) : RandomAccessFile,CONSTRUCTOR;
                      END;

  Reader* = POINTER TO ABSTRACT RECORD (java_lang.Object)
              lock! : java_lang.Object;
            STATIC
              PROCEDURE Init!() : Reader,CONSTRUCTOR;
              PROCEDURE Init!(p0 : java_lang.Object) : Reader,CONSTRUCTOR;
            END;

  SequenceInputStream* = POINTER TO EXTENSIBLE RECORD (InputStream)
                         STATIC
                           PROCEDURE Init*(p0 : InputStream;
                                           p1 : InputStream) : SequenceInputStream,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : java_util.Enumeration) : SequenceInputStream,CONSTRUCTOR;
                         END;

  Serializable* = POINTER TO INTERFACE RECORD (java_lang.Object)
                  STATIC
                    serialVersionUID* = 1196656838076753133;
                  END;

  SerializablePermission* = POINTER TO RECORD (java_security.BasicPermission)
                            STATIC
                              PROCEDURE Init*(p0 : java_lang.String) : SerializablePermission,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : java_lang.String;
                                              p1 : java_lang.String) : SerializablePermission,CONSTRUCTOR;
                            END;

  StreamCorruptedException* = POINTER TO EXTENSIBLE RECORD (ObjectStreamException)
                              STATIC
                                PROCEDURE Init*() : StreamCorruptedException,CONSTRUCTOR;
                                PROCEDURE Init*(p0 : java_lang.String) : StreamCorruptedException,CONSTRUCTOR;
                              END;

  StreamTokenizer* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                       ttype* : INTEGER;
                       sval* : java_lang.String;
                       nval* : REAL;
                     STATIC
                       TT_EOF* = -1;
                       TT_EOL* = 10;
                       TT_NUMBER* = -2;
                       TT_WORD* = -3;
                       PROCEDURE Init*(p0 : InputStream) : StreamTokenizer,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : Reader) : StreamTokenizer,CONSTRUCTOR;
                     END;

  StringBufferInputStream* = POINTER TO EXTENSIBLE RECORD (InputStream)
                               buffer! : java_lang.String;
                               pos! : INTEGER;
                               count! : INTEGER;
                             STATIC
                               PROCEDURE Init*(p0 : java_lang.String) : StringBufferInputStream,CONSTRUCTOR;
                             END;

  StringReader* = POINTER TO EXTENSIBLE RECORD (Reader)
                  STATIC
                    PROCEDURE Init*(p0 : java_lang.String) : StringReader,CONSTRUCTOR;
                  END;

  StringWriter* = POINTER TO EXTENSIBLE RECORD (Writer)
                  STATIC
                    PROCEDURE Init*() : StringWriter,CONSTRUCTOR;
                    PROCEDURE Init*(p0 : INTEGER) : StringWriter,CONSTRUCTOR;
                  END;

  SyncFailedException* = POINTER TO EXTENSIBLE RECORD (IOException)
                         STATIC
                           PROCEDURE Init*(p0 : java_lang.String) : SyncFailedException,CONSTRUCTOR;
                         END;

  UnsupportedEncodingException* = POINTER TO EXTENSIBLE RECORD (IOException)
                                  STATIC
                                    PROCEDURE Init*() : UnsupportedEncodingException,CONSTRUCTOR;
                                    PROCEDURE Init*(p0 : java_lang.String) : UnsupportedEncodingException,CONSTRUCTOR;
                                  END;

  UTFDataFormatException* = POINTER TO EXTENSIBLE RECORD (IOException)
                            STATIC
                              PROCEDURE Init*() : UTFDataFormatException,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : java_lang.String) : UTFDataFormatException,CONSTRUCTOR;
                            END;

  WriteAbortedException* = POINTER TO EXTENSIBLE RECORD (ObjectStreamException)
                             detail* : java_lang.Exception;
                           STATIC
                             PROCEDURE Init*(p0 : java_lang.String;
                                             p1 : java_lang.Exception) : WriteAbortedException,CONSTRUCTOR;
                           END;

  Writer* = POINTER TO ABSTRACT RECORD (java_lang.Object)
              lock! : java_lang.Object;
            STATIC
              PROCEDURE Init!() : Writer,CONSTRUCTOR;
              PROCEDURE Init!(p0 : java_lang.Object) : Writer,CONSTRUCTOR;
            END;




PROCEDURE (self:BufferedInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:BufferedInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:BufferedInputStream) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:BufferedInputStream) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:BufferedInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:BufferedInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:BufferedInputStream) reset*(),EXTENSIBLE;

PROCEDURE (self:BufferedInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:BufferedOutputStream) flush*(),EXTENSIBLE;

PROCEDURE (self:BufferedOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:BufferedOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:BufferedReader) close*(),EXTENSIBLE;

PROCEDURE (self:BufferedReader) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:BufferedReader) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:BufferedReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:BufferedReader) read*(IN  p0 : ARRAY OF CHAR;
                                          p1 : INTEGER;
                                          p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:BufferedReader) readLine*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:BufferedReader) ready*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:BufferedReader) reset*(),EXTENSIBLE;

PROCEDURE (self:BufferedReader) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:BufferedWriter) close*(),EXTENSIBLE;

PROCEDURE (self:BufferedWriter) flush*(),EXTENSIBLE;

PROCEDURE (self:BufferedWriter) newLine*(),NEW,EXTENSIBLE;

PROCEDURE (self:BufferedWriter) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:BufferedWriter) write*(p0 : java_lang.String;
                                       p1 : INTEGER;
                                       p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:BufferedWriter) write*(IN  p0 : ARRAY OF CHAR;
                                           p1 : INTEGER;
                                           p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                                p1 : INTEGER;
                                                p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) reset*(),EXTENSIBLE;

PROCEDURE (self:ByteArrayInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) size*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) toByteArray*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) toString*(p0 : INTEGER) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) toString*(p0 : java_lang.String) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                                  p1 : INTEGER;
                                                  p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:ByteArrayOutputStream) writeTo*(p0 : OutputStream),NEW,EXTENSIBLE;

PROCEDURE (self:CharArrayReader) close*(),EXTENSIBLE;

PROCEDURE (self:CharArrayReader) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:CharArrayReader) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:CharArrayReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:CharArrayReader) read*(IN  p0 : ARRAY OF CHAR;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:CharArrayReader) ready*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:CharArrayReader) reset*(),EXTENSIBLE;

PROCEDURE (self:CharArrayReader) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) close*(),EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) flush*(),EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) size*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) toCharArray*() : POINTER TO ARRAY OF CHAR,NEW,EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) write*(p0 : java_lang.String;
                                        p1 : INTEGER;
                                        p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) write*(IN  p0 : ARRAY OF CHAR;
                                            p1 : INTEGER;
                                            p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:CharArrayWriter) writeTo*(p0 : Writer),NEW,EXTENSIBLE;

PROCEDURE (self:DataInput) readBoolean*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readByte*() : BYTE,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readChar*() : CHAR,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readDouble*() : REAL,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readFloat*() : SHORTREAL,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readFully*(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

PROCEDURE (self:DataInput) readFully*(IN  p0 : ARRAY OF BYTE;
                                          p1 : INTEGER;
                                          p2 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:DataInput) readInt*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readLine*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readLong*() : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readShort*() : SHORTINT,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readUTF*() : java_lang.String,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readUnsignedByte*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:DataInput) readUnsignedShort*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:DataInput) skipBytes*(p0 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:DataInputStream) read*(IN  p0 : ARRAY OF BYTE) : INTEGER;

PROCEDURE (self:DataInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : INTEGER;

PROCEDURE (self:DataInputStream) readBoolean*() : BOOLEAN,NEW;

PROCEDURE (self:DataInputStream) readByte*() : BYTE,NEW;

PROCEDURE (self:DataInputStream) readChar*() : CHAR,NEW;

PROCEDURE (self:DataInputStream) readDouble*() : REAL,NEW;

PROCEDURE (self:DataInputStream) readFloat*() : SHORTREAL,NEW;

PROCEDURE (self:DataInputStream) readFully*(IN  p0 : ARRAY OF BYTE),NEW;

PROCEDURE (self:DataInputStream) readFully*(IN  p0 : ARRAY OF BYTE;
                                                p1 : INTEGER;
                                                p2 : INTEGER),NEW;

PROCEDURE (self:DataInputStream) readInt*() : INTEGER,NEW;

PROCEDURE (self:DataInputStream) readLine*() : java_lang.String,NEW;

PROCEDURE (self:DataInputStream) readLong*() : LONGINT,NEW;

PROCEDURE (self:DataInputStream) readShort*() : SHORTINT,NEW;

PROCEDURE (self:DataInputStream) readUTF*() : java_lang.String,NEW;

PROCEDURE (self:DataInputStream) readUnsignedByte*() : INTEGER,NEW;

PROCEDURE (self:DataInputStream) readUnsignedShort*() : INTEGER,NEW;

PROCEDURE (self:DataInputStream) skipBytes*(p0 : INTEGER) : INTEGER,NEW;

PROCEDURE (self:DataOutput) write*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) write*(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) write*(IN  p0 : ARRAY OF BYTE;
                                       p1 : INTEGER;
                                       p2 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeBoolean*(p0 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeByte*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeBytes*(p0 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeChar*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeChars*(p0 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeDouble*(p0 : REAL),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeFloat*(p0 : SHORTREAL),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeInt*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeLong*(p0 : LONGINT),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeShort*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:DataOutput) writeUTF*(p0 : java_lang.String),NEW,ABSTRACT;

PROCEDURE (self:DataOutputStream) flush*(),EXTENSIBLE;

PROCEDURE (self:DataOutputStream) size*() : INTEGER,NEW;

PROCEDURE (self:DataOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:DataOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:DataOutputStream) writeBoolean*(p0 : BOOLEAN),NEW;

PROCEDURE (self:DataOutputStream) writeByte*(p0 : INTEGER),NEW;

PROCEDURE (self:DataOutputStream) writeBytes*(p0 : java_lang.String),NEW;

PROCEDURE (self:DataOutputStream) writeChar*(p0 : INTEGER),NEW;

PROCEDURE (self:DataOutputStream) writeChars*(p0 : java_lang.String),NEW;

PROCEDURE (self:DataOutputStream) writeDouble*(p0 : REAL),NEW;

PROCEDURE (self:DataOutputStream) writeFloat*(p0 : SHORTREAL),NEW;

PROCEDURE (self:DataOutputStream) writeInt*(p0 : INTEGER),NEW;

PROCEDURE (self:DataOutputStream) writeLong*(p0 : LONGINT),NEW;

PROCEDURE (self:DataOutputStream) writeShort*(p0 : INTEGER),NEW;

PROCEDURE (self:DataOutputStream) writeUTF*(p0 : java_lang.String),NEW;

PROCEDURE (self:Externalizable) readExternal*(p0 : ObjectInput),NEW,ABSTRACT;

PROCEDURE (self:Externalizable) writeExternal*(p0 : ObjectOutput),NEW,ABSTRACT;

PROCEDURE (self:File) canRead*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) canWrite*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) compareTo*(p0 : File) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:File) compareTo*(p0 : java_lang.Object) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:File) createNewFile*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) delete*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) deleteOnExit*(),NEW,EXTENSIBLE;

PROCEDURE (self:File) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:File) exists*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) getAbsoluteFile*() : File,NEW,EXTENSIBLE;

PROCEDURE (self:File) getAbsolutePath*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:File) getCanonicalFile*() : File,NEW,EXTENSIBLE;

PROCEDURE (self:File) getCanonicalPath*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:File) getName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:File) getParent*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:File) getParentFile*() : File,NEW,EXTENSIBLE;

PROCEDURE (self:File) getPath*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:File) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:File) isAbsolute*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) isDirectory*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) isFile*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) isHidden*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) lastModified*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:File) length*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:File) list*() : POINTER TO ARRAY OF java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:File) list*(p0 : FilenameFilter) : POINTER TO ARRAY OF java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:File) listFiles*() : POINTER TO ARRAY OF File,NEW,EXTENSIBLE;

PROCEDURE (self:File) listFiles*(p0 : FileFilter) : POINTER TO ARRAY OF File,NEW,EXTENSIBLE;

PROCEDURE (self:File) listFiles*(p0 : FilenameFilter) : POINTER TO ARRAY OF File,NEW,EXTENSIBLE;

PROCEDURE (self:File) mkdir*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) mkdirs*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) renameTo*(p0 : File) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) setLastModified*(p0 : LONGINT) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) setReadOnly*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:File) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:File) toURL*() : java_net.URL,NEW,EXTENSIBLE;

PROCEDURE (self:FileDescriptor) sync*(),NEW,EXTENSIBLE;

PROCEDURE (self:FileDescriptor) valid*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:FileFilter) accept*(p0 : File) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:FileInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:FileInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:FileInputStream) finalize!(),EXTENSIBLE;

PROCEDURE (self:FileInputStream) getFD*() : FileDescriptor,NEW;

PROCEDURE (self:FileInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:FileInputStream) read*(IN  p0 : ARRAY OF BYTE) : INTEGER,EXTENSIBLE;

PROCEDURE (self:FileInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:FileInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:FilenameFilter) accept*(p0 : File;
                                        p1 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:FileOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:FileOutputStream) finalize!(),EXTENSIBLE;

PROCEDURE (self:FileOutputStream) getFD*() : FileDescriptor,NEW;

PROCEDURE (self:FileOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FileOutputStream) write*(IN  p0 : ARRAY OF BYTE),EXTENSIBLE;

PROCEDURE (self:FileOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FilePermission) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:FilePermission) getActions*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:FilePermission) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:FilePermission) implies*(p0 : java_security.Permission) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:FilePermission) newPermissionCollection*() : java_security.PermissionCollection,EXTENSIBLE;

PROCEDURE (self:FilterInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:FilterInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:FilterInputStream) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FilterInputStream) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:FilterInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:FilterInputStream) read*(IN  p0 : ARRAY OF BYTE) : INTEGER,EXTENSIBLE;

PROCEDURE (self:FilterInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:FilterInputStream) reset*(),EXTENSIBLE;

PROCEDURE (self:FilterInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:FilterOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:FilterOutputStream) flush*(),EXTENSIBLE;

PROCEDURE (self:FilterOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FilterOutputStream) write*(IN  p0 : ARRAY OF BYTE),EXTENSIBLE;

PROCEDURE (self:FilterOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FilterReader) close*(),EXTENSIBLE;

PROCEDURE (self:FilterReader) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FilterReader) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:FilterReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:FilterReader) read*(IN  p0 : ARRAY OF CHAR;
                                        p1 : INTEGER;
                                        p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:FilterReader) ready*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:FilterReader) reset*(),EXTENSIBLE;

PROCEDURE (self:FilterReader) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:FilterWriter) close*(),EXTENSIBLE;

PROCEDURE (self:FilterWriter) flush*(),EXTENSIBLE;

PROCEDURE (self:FilterWriter) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FilterWriter) write*(p0 : java_lang.String;
                                     p1 : INTEGER;
                                     p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:FilterWriter) write*(IN  p0 : ARRAY OF CHAR;
                                         p1 : INTEGER;
                                         p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:InputStream) available*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:InputStream) close*(),NEW,EXTENSIBLE;

PROCEDURE (self:InputStream) mark*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:InputStream) markSupported*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:InputStream) read*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:InputStream) read*(IN  p0 : ARRAY OF BYTE) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:InputStream) read*(IN  p0 : ARRAY OF BYTE;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:InputStream) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:InputStream) skip*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:InputStreamReader) close*(),EXTENSIBLE;

PROCEDURE (self:InputStreamReader) getEncoding*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:InputStreamReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:InputStreamReader) read*(IN  p0 : ARRAY OF CHAR;
                                             p1 : INTEGER;
                                             p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:InputStreamReader) ready*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:InvalidClassException) getMessage*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) getLineNumber*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) reset*(),EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) setLineNumber*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:LineNumberInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:LineNumberReader) getLineNumber*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:LineNumberReader) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:LineNumberReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:LineNumberReader) read*(IN  p0 : ARRAY OF CHAR;
                                            p1 : INTEGER;
                                            p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:LineNumberReader) readLine*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:LineNumberReader) reset*(),EXTENSIBLE;

PROCEDURE (self:LineNumberReader) setLineNumber*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:LineNumberReader) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:ObjectInput) available*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ObjectInput) close*(),NEW,ABSTRACT;

PROCEDURE (self:ObjectInput) read*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ObjectInput) read*(IN  p0 : ARRAY OF BYTE) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ObjectInput) read*(IN  p0 : ARRAY OF BYTE;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ObjectInput) readObject*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ObjectInput) skip*(p0 : LONGINT) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) defaulted*(p0 : java_lang.String) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : BYTE) : BYTE,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : CHAR) : CHAR,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : REAL) : REAL,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : SHORTREAL) : SHORTREAL,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : LONGINT) : LONGINT,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : SHORTINT) : SHORTINT,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) get*(p0 : java_lang.String;
                                                 p1 : BOOLEAN) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream$GetField) getObjectStreamClass*() : ObjectStreamClass,NEW,ABSTRACT;

PROCEDURE (self:ObjectInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) defaultReadObject*(),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) enableResolveObject!(p0 : BOOLEAN) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readBoolean*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readByte*() : BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readChar*() : CHAR,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readDouble*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readFields*() : ObjectInputStream$GetField,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readFloat*() : SHORTREAL,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readFully*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readFully*(IN  p0 : ARRAY OF BYTE;
                                                  p1 : INTEGER;
                                                  p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readInt*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readLine*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readLong*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readObject*() : java_lang.Object,NEW;

PROCEDURE (self:ObjectInputStream) readObjectOverride!() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readShort*() : SHORTINT,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readStreamHeader!(),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readUTF*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readUnsignedByte*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) readUnsignedShort*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) registerValidation*(p0 : ObjectInputValidation;
                                                       p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) resolveClass!(p0 : ObjectStreamClass) : java_lang.Class,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) resolveObject!(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputStream) skipBytes*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectInputValidation) validateObject*(),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutput) close*(),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutput) flush*(),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutput) write*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutput) write*(IN  p0 : ARRAY OF BYTE),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutput) write*(IN  p0 : ARRAY OF BYTE;
                                         p1 : INTEGER;
                                         p2 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutput) writeObject*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : BYTE),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : CHAR),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : REAL),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : SHORTREAL),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : LONGINT),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : SHORTINT),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) put*(p0 : java_lang.String;
                                                  p1 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream$PutField) write*(p0 : ObjectOutput),NEW,ABSTRACT;

PROCEDURE (self:ObjectOutputStream) annotateClass!(p0 : java_lang.Class),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) defaultWriteObject*(),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) drain!(),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) enableReplaceObject!(p0 : BOOLEAN) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) flush*(),EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) putFields*() : ObjectOutputStream$PutField,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) replaceObject!(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) useProtocolVersion*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) write*(IN  p0 : ARRAY OF BYTE),EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeBoolean*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeByte*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeBytes*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeChar*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeChars*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeDouble*(p0 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeFields*(),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeFloat*(p0 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeInt*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeLong*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeObject*(p0 : java_lang.Object),NEW;

PROCEDURE (self:ObjectOutputStream) writeObjectOverride!(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeShort*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeStreamHeader!(),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectOutputStream) writeUTF*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamClass) forClass*() : java_lang.Class,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamClass) getField*(p0 : java_lang.String) : ObjectStreamField,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamClass) getFields*() : POINTER TO ARRAY OF ObjectStreamField,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamClass) getName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamClass) getSerialVersionUID*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamClass) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) compareTo*(p0 : java_lang.Object) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) getName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) getOffset*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) getType*() : java_lang.Class,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) getTypeCode*() : CHAR,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) getTypeString*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) isPrimitive*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) setOffset!(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ObjectStreamField) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:OutputStream) close*(),NEW,EXTENSIBLE;

PROCEDURE (self:OutputStream) flush*(),NEW,EXTENSIBLE;

PROCEDURE (self:OutputStream) write*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:OutputStream) write*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:OutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                         p1 : INTEGER;
                                         p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:OutputStreamWriter) close*(),EXTENSIBLE;

PROCEDURE (self:OutputStreamWriter) flush*(),EXTENSIBLE;

PROCEDURE (self:OutputStreamWriter) getEncoding*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:OutputStreamWriter) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:OutputStreamWriter) write*(p0 : java_lang.String;
                                           p1 : INTEGER;
                                           p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:OutputStreamWriter) write*(IN  p0 : ARRAY OF CHAR;
                                               p1 : INTEGER;
                                               p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PipedInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:PipedInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:PipedInputStream) connect*(p0 : PipedOutputStream),NEW,EXTENSIBLE;

PROCEDURE (self:PipedInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:PipedInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                            p1 : INTEGER;
                                            p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:PipedInputStream) receive!(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PipedOutputStream) close*(),EXTENSIBLE;

PROCEDURE (self:PipedOutputStream) connect*(p0 : PipedInputStream),NEW,EXTENSIBLE;

PROCEDURE (self:PipedOutputStream) flush*(),EXTENSIBLE;

PROCEDURE (self:PipedOutputStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PipedOutputStream) write*(IN  p0 : ARRAY OF BYTE;
                                              p1 : INTEGER;
                                              p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PipedReader) close*(),EXTENSIBLE;

PROCEDURE (self:PipedReader) connect*(p0 : PipedWriter),NEW,EXTENSIBLE;

PROCEDURE (self:PipedReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:PipedReader) read*(IN  p0 : ARRAY OF CHAR;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:PipedReader) ready*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:PipedWriter) close*(),EXTENSIBLE;

PROCEDURE (self:PipedWriter) connect*(p0 : PipedReader),NEW,EXTENSIBLE;

PROCEDURE (self:PipedWriter) flush*(),EXTENSIBLE;

PROCEDURE (self:PipedWriter) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PipedWriter) write*(IN  p0 : ARRAY OF CHAR;
                                        p1 : INTEGER;
                                        p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PrintStream) checkError*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) close*(),EXTENSIBLE;

PROCEDURE (self:PrintStream) flush*(),EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) print*(IN  p0 : ARRAY OF CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) println*(IN  p0 : ARRAY OF CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) setError!(),NEW,EXTENSIBLE;

PROCEDURE (self:PrintStream) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PrintStream) write*(IN  p0 : ARRAY OF BYTE;
                                        p1 : INTEGER;
                                        p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PrintWriter) checkError*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) close*(),EXTENSIBLE;

PROCEDURE (self:PrintWriter) flush*(),EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) print*(IN  p0 : ARRAY OF CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : REAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : SHORTREAL),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) println*(IN  p0 : ARRAY OF CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) setError!(),NEW,EXTENSIBLE;

PROCEDURE (self:PrintWriter) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PrintWriter) write*(p0 : java_lang.String),EXTENSIBLE;

PROCEDURE (self:PrintWriter) write*(p0 : java_lang.String;
                                    p1 : INTEGER;
                                    p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PrintWriter) write*(IN  p0 : ARRAY OF CHAR),EXTENSIBLE;

PROCEDURE (self:PrintWriter) write*(IN  p0 : ARRAY OF CHAR;
                                        p1 : INTEGER;
                                        p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) unread*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) unread*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:PushbackInputStream) unread*(IN  p0 : ARRAY OF BYTE;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PushbackReader) close*(),EXTENSIBLE;

PROCEDURE (self:PushbackReader) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:PushbackReader) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:PushbackReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:PushbackReader) read*(IN  p0 : ARRAY OF CHAR;
                                          p1 : INTEGER;
                                          p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:PushbackReader) ready*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:PushbackReader) reset*(),EXTENSIBLE;

PROCEDURE (self:PushbackReader) unread*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:PushbackReader) unread*(IN  p0 : ARRAY OF CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:PushbackReader) unread*(IN  p0 : ARRAY OF CHAR;
                                            p1 : INTEGER;
                                            p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) close*(),NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) getFD*() : FileDescriptor,NEW;

PROCEDURE (self:RandomAccessFile) getFilePointer*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) length*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) read*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) read*(IN  p0 : ARRAY OF BYTE) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) read*(IN  p0 : ARRAY OF BYTE;
                                            p1 : INTEGER;
                                            p2 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) readBoolean*() : BOOLEAN,NEW;

PROCEDURE (self:RandomAccessFile) readByte*() : BYTE,NEW;

PROCEDURE (self:RandomAccessFile) readChar*() : CHAR,NEW;

PROCEDURE (self:RandomAccessFile) readDouble*() : REAL,NEW;

PROCEDURE (self:RandomAccessFile) readFloat*() : SHORTREAL,NEW;

PROCEDURE (self:RandomAccessFile) readFully*(IN  p0 : ARRAY OF BYTE),NEW;

PROCEDURE (self:RandomAccessFile) readFully*(IN  p0 : ARRAY OF BYTE;
                                                 p1 : INTEGER;
                                                 p2 : INTEGER),NEW;

PROCEDURE (self:RandomAccessFile) readInt*() : INTEGER,NEW;

PROCEDURE (self:RandomAccessFile) readLine*() : java_lang.String,NEW;

PROCEDURE (self:RandomAccessFile) readLong*() : LONGINT,NEW;

PROCEDURE (self:RandomAccessFile) readShort*() : SHORTINT,NEW;

PROCEDURE (self:RandomAccessFile) readUTF*() : java_lang.String,NEW;

PROCEDURE (self:RandomAccessFile) readUnsignedByte*() : INTEGER,NEW;

PROCEDURE (self:RandomAccessFile) readUnsignedShort*() : INTEGER,NEW;

PROCEDURE (self:RandomAccessFile) seek*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) setLength*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) skipBytes*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) write*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) write*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) write*(IN  p0 : ARRAY OF BYTE;
                                             p1 : INTEGER;
                                             p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:RandomAccessFile) writeBoolean*(p0 : BOOLEAN),NEW;

PROCEDURE (self:RandomAccessFile) writeByte*(p0 : INTEGER),NEW;

PROCEDURE (self:RandomAccessFile) writeBytes*(p0 : java_lang.String),NEW;

PROCEDURE (self:RandomAccessFile) writeChar*(p0 : INTEGER),NEW;

PROCEDURE (self:RandomAccessFile) writeChars*(p0 : java_lang.String),NEW;

PROCEDURE (self:RandomAccessFile) writeDouble*(p0 : REAL),NEW;

PROCEDURE (self:RandomAccessFile) writeFloat*(p0 : SHORTREAL),NEW;

PROCEDURE (self:RandomAccessFile) writeInt*(p0 : INTEGER),NEW;

PROCEDURE (self:RandomAccessFile) writeLong*(p0 : LONGINT),NEW;

PROCEDURE (self:RandomAccessFile) writeShort*(p0 : INTEGER),NEW;

PROCEDURE (self:RandomAccessFile) writeUTF*(p0 : java_lang.String),NEW;

PROCEDURE (self:Reader) close*(),NEW,ABSTRACT;

PROCEDURE (self:Reader) mark*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Reader) markSupported*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Reader) read*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Reader) read*(IN  p0 : ARRAY OF CHAR) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Reader) read*(IN  p0 : ARRAY OF CHAR;
                                  p1 : INTEGER;
                                  p2 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Reader) ready*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Reader) reset*(),NEW,EXTENSIBLE;

PROCEDURE (self:Reader) skip*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:SequenceInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:SequenceInputStream) close*(),EXTENSIBLE;

PROCEDURE (self:SequenceInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:SequenceInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                               p1 : INTEGER;
                                               p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) commentChar*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) eolIsSignificant*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) lineno*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) lowerCaseMode*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) nextToken*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) ordinaryChar*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) ordinaryChars*(p0 : INTEGER;
                                                p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) parseNumbers*(),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) pushBack*(),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) quoteChar*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) resetSyntax*(),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) slashSlashComments*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) slashStarComments*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) whitespaceChars*(p0 : INTEGER;
                                                  p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:StreamTokenizer) wordChars*(p0 : INTEGER;
                                            p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:StringBufferInputStream) available*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringBufferInputStream) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringBufferInputStream) read*(IN  p0 : ARRAY OF BYTE;
                                                   p1 : INTEGER;
                                                   p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringBufferInputStream) reset*(),EXTENSIBLE;

PROCEDURE (self:StringBufferInputStream) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:StringReader) close*(),EXTENSIBLE;

PROCEDURE (self:StringReader) mark*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:StringReader) markSupported*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:StringReader) read*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringReader) read*(IN  p0 : ARRAY OF CHAR;
                                        p1 : INTEGER;
                                        p2 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringReader) ready*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:StringReader) reset*(),EXTENSIBLE;

PROCEDURE (self:StringReader) skip*(p0 : LONGINT) : LONGINT,EXTENSIBLE;

PROCEDURE (self:StringWriter) close*(),EXTENSIBLE;

PROCEDURE (self:StringWriter) flush*(),EXTENSIBLE;

PROCEDURE (self:StringWriter) getBuffer*() : java_lang.StringBuffer,NEW,EXTENSIBLE;

PROCEDURE (self:StringWriter) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:StringWriter) write*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:StringWriter) write*(p0 : java_lang.String),EXTENSIBLE;

PROCEDURE (self:StringWriter) write*(p0 : java_lang.String;
                                     p1 : INTEGER;
                                     p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:StringWriter) write*(IN  p0 : ARRAY OF CHAR;
                                         p1 : INTEGER;
                                         p2 : INTEGER),EXTENSIBLE;

PROCEDURE (self:WriteAbortedException) getMessage*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:Writer) close*(),NEW,ABSTRACT;

PROCEDURE (self:Writer) flush*(),NEW,ABSTRACT;

PROCEDURE (self:Writer) write*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Writer) write*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:Writer) write*(p0 : java_lang.String;
                               p1 : INTEGER;
                               p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Writer) write*(IN  p0 : ARRAY OF CHAR),NEW,EXTENSIBLE;

PROCEDURE (self:Writer) write*(IN  p0 : ARRAY OF CHAR;
                                   p1 : INTEGER;
                                   p2 : INTEGER),NEW,ABSTRACT;

END java_io.