    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.