    FOREIGN MODULE java_lang;

    IMPORT
        java_io,
        java_security,
        java_lang_reflect,
        java_net,
        java_util,
        sun_misc,
        java_util_jar,
        java_awt,
        sun_io;

    TYPE

      AbstractMethodError* = POINTER TO EXTENSIBLE RECORD (IncompatibleClassChangeError)
                             STATIC
                               PROCEDURE Init*() : AbstractMethodError,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : String) : AbstractMethodError,CONSTRUCTOR;
                             END;

      ArithmeticException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                             STATIC
                               PROCEDURE Init*() : ArithmeticException,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : String) : ArithmeticException,CONSTRUCTOR;
                             END;

      ArrayIndexOutOfBoundsException* = POINTER TO EXTENSIBLE RECORD (IndexOutOfBoundsException)
                                        STATIC
                                          PROCEDURE Init*() : ArrayIndexOutOfBoundsException,CONSTRUCTOR;
                                          PROCEDURE Init*(p0 : INTEGER) : ArrayIndexOutOfBoundsException,CONSTRUCTOR;
                                          PROCEDURE Init*(p0 : String) : ArrayIndexOutOfBoundsException,CONSTRUCTOR;
                                        END;

      ArrayStoreException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                             STATIC
                               PROCEDURE Init*() : ArrayStoreException,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : String) : ArrayStoreException,CONSTRUCTOR;
                             END;

      Boolean* = POINTER TO RECORD (Object + java_io.Serializable)
                 STATIC
                   TRUE* : Boolean;
                   FALSE* : Boolean;
                   TYPE* : Class;
                   PROCEDURE Init*(p0 : String) : Boolean,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : BOOLEAN) : Boolean,CONSTRUCTOR;
                   PROCEDURE getBoolean*(p0 : String) : BOOLEAN;
                   PROCEDURE valueOf*(p0 : String) : Boolean;
                 END;

      Byte* = POINTER TO RECORD (Number + Comparable)
              STATIC
                MIN_VALUE* = -128;
                MAX_VALUE* = 127;
                TYPE* : Class;
                PROCEDURE Init*(p0 : BYTE) : Byte,CONSTRUCTOR;
                PROCEDURE Init*(p0 : String) : Byte,CONSTRUCTOR;
                PROCEDURE decode*(p0 : String) : Byte;
                PROCEDURE parseByte*(p0 : String) : BYTE;
                PROCEDURE parseByte*(p0 : String;
                                     p1 : INTEGER) : BYTE;
                PROCEDURE toString*(p0 : BYTE) : String;
                PROCEDURE valueOf*(p0 : String) : Byte;
                PROCEDURE valueOf*(p0 : String;
                                   p1 : INTEGER) : Byte;
              END;

      Character$Subset* = POINTER TO EXTENSIBLE RECORD (Object)
                          STATIC
                            PROCEDURE Init!(p0 : String) : Character$Subset,CONSTRUCTOR;
                          END;

      Character$UnicodeBlock* = POINTER TO RECORD (Character$Subset)
                                STATIC
                                  BASIC_LATIN* : Character$UnicodeBlock;
                                  LATIN_1_SUPPLEMENT* : Character$UnicodeBlock;
                                  LATIN_EXTENDED_A* : Character$UnicodeBlock;
                                  LATIN_EXTENDED_B* : Character$UnicodeBlock;
                                  IPA_EXTENSIONS* : Character$UnicodeBlock;
                                  SPACING_MODIFIER_LETTERS* : Character$UnicodeBlock;
                                  COMBINING_DIACRITICAL_MARKS* : Character$UnicodeBlock;
                                  GREEK* : Character$UnicodeBlock;
                                  CYRILLIC* : Character$UnicodeBlock;
                                  ARMENIAN* : Character$UnicodeBlock;
                                  HEBREW* : Character$UnicodeBlock;
                                  ARABIC* : Character$UnicodeBlock;
                                  DEVANAGARI* : Character$UnicodeBlock;
                                  BENGALI* : Character$UnicodeBlock;
                                  GURMUKHI* : Character$UnicodeBlock;
                                  GUJARATI* : Character$UnicodeBlock;
                                  ORIYA* : Character$UnicodeBlock;
                                  TAMIL* : Character$UnicodeBlock;
                                  TELUGU* : Character$UnicodeBlock;
                                  KANNADA* : Character$UnicodeBlock;
                                  MALAYALAM* : Character$UnicodeBlock;
                                  THAI* : Character$UnicodeBlock;
                                  LAO* : Character$UnicodeBlock;
                                  TIBETAN* : Character$UnicodeBlock;
                                  GEORGIAN* : Character$UnicodeBlock;
                                  HANGUL_JAMO* : Character$UnicodeBlock;
                                  LATIN_EXTENDED_ADDITIONAL* : Character$UnicodeBlock;
                                  GREEK_EXTENDED* : Character$UnicodeBlock;
                                  GENERAL_PUNCTUATION* : Character$UnicodeBlock;
                                  SUPERSCRIPTS_AND_SUBSCRIPTS* : Character$UnicodeBlock;
                                  CURRENCY_SYMBOLS* : Character$UnicodeBlock;
                                  COMBINING_MARKS_FOR_SYMBOLS* : Character$UnicodeBlock;
                                  LETTERLIKE_SYMBOLS* : Character$UnicodeBlock;
                                  NUMBER_FORMS* : Character$UnicodeBlock;
                                  ARROWS* : Character$UnicodeBlock;
                                  MATHEMATICAL_OPERATORS* : Character$UnicodeBlock;
                                  MISCELLANEOUS_TECHNICAL* : Character$UnicodeBlock;
                                  CONTROL_PICTURES* : Character$UnicodeBlock;
                                  OPTICAL_CHARACTER_RECOGNITION* : Character$UnicodeBlock;
                                  ENCLOSED_ALPHANUMERICS* : Character$UnicodeBlock;
                                  BOX_DRAWING* : Character$UnicodeBlock;
                                  BLOCK_ELEMENTS* : Character$UnicodeBlock;
                                  GEOMETRIC_SHAPES* : Character$UnicodeBlock;
                                  MISCELLANEOUS_SYMBOLS* : Character$UnicodeBlock;
                                  DINGBATS* : Character$UnicodeBlock;
                                  CJK_SYMBOLS_AND_PUNCTUATION* : Character$UnicodeBlock;
                                  HIRAGANA* : Character$UnicodeBlock;
                                  KATAKANA* : Character$UnicodeBlock;
                                  BOPOMOFO* : Character$UnicodeBlock;
                                  HANGUL_COMPATIBILITY_JAMO* : Character$UnicodeBlock;
                                  KANBUN* : Character$UnicodeBlock;
                                  ENCLOSED_CJK_LETTERS_AND_MONTHS* : Character$UnicodeBlock;
                                  CJK_COMPATIBILITY* : Character$UnicodeBlock;
                                  CJK_UNIFIED_IDEOGRAPHS* : Character$UnicodeBlock;
                                  HANGUL_SYLLABLES* : Character$UnicodeBlock;
                                  SURROGATES_AREA* : Character$UnicodeBlock;
                                  PRIVATE_USE_AREA* : Character$UnicodeBlock;
                                  CJK_COMPATIBILITY_IDEOGRAPHS* : Character$UnicodeBlock;
                                  ALPHABETIC_PRESENTATION_FORMS* : Character$UnicodeBlock;
                                  ARABIC_PRESENTATION_FORMS_A* : Character$UnicodeBlock;
                                  COMBINING_HALF_MARKS* : Character$UnicodeBlock;
                                  CJK_COMPATIBILITY_FORMS* : Character$UnicodeBlock;
                                  SMALL_FORM_VARIANTS* : Character$UnicodeBlock;
                                  ARABIC_PRESENTATION_FORMS_B* : Character$UnicodeBlock;
                                  HALFWIDTH_AND_FULLWIDTH_FORMS* : Character$UnicodeBlock;
                                  SPECIALS* : Character$UnicodeBlock;
                                  PROCEDURE of*(p0 : CHAR) : Character$UnicodeBlock;
                                END;

      Character* = POINTER TO RECORD (Object + java_io.Serializable + Comparable)
                   STATIC
                     MIN_RADIX* = 2;
                     MAX_RADIX* = 36;
                     MIN_VALUE* = 0;
                     MAX_VALUE* = 65535;
                     TYPE* : Class;
                     UNASSIGNED* = 0;
                     UPPERCASE_LETTER* = 1;
                     LOWERCASE_LETTER* = 2;
                     TITLECASE_LETTER* = 3;
                     MODIFIER_LETTER* = 4;
                     OTHER_LETTER* = 5;
                     NON_SPACING_MARK* = 6;
                     ENCLOSING_MARK* = 7;
                     COMBINING_SPACING_MARK* = 8;
                     DECIMAL_DIGIT_NUMBER* = 9;
                     LETTER_NUMBER* = 10;
                     OTHER_NUMBER* = 11;
                     SPACE_SEPARATOR* = 12;
                     LINE_SEPARATOR* = 13;
                     PARAGRAPH_SEPARATOR* = 14;
                     CONTROL* = 15;
                     FORMAT* = 16;
                     PRIVATE_USE* = 18;
                     SURROGATE* = 19;
                     DASH_PUNCTUATION* = 20;
                     START_PUNCTUATION* = 21;
                     END_PUNCTUATION* = 22;
                     CONNECTOR_PUNCTUATION* = 23;
                     OTHER_PUNCTUATION* = 24;
                     MATH_SYMBOL* = 25;
                     CURRENCY_SYMBOL* = 26;
                     MODIFIER_SYMBOL* = 27;
                     OTHER_SYMBOL* = 28;
                     PROCEDURE Init*(p0 : CHAR) : Character,CONSTRUCTOR;
                     PROCEDURE digit*(p0 : CHAR;
                                      p1 : INTEGER) : INTEGER;
                     PROCEDURE forDigit*(p0 : INTEGER;
                                         p1 : INTEGER) : CHAR;
                     PROCEDURE getNumericValue*(p0 : CHAR) : INTEGER;
                     PROCEDURE getType*(p0 : CHAR) : INTEGER;
                     PROCEDURE isDefined*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isDigit*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isISOControl*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isIdentifierIgnorable*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isJavaIdentifierPart*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isJavaIdentifierStart*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isJavaLetter*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isJavaLetterOrDigit*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isLetter*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isLetterOrDigit*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isLowerCase*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isSpace*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isSpaceChar*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isTitleCase*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isUnicodeIdentifierPart*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isUnicodeIdentifierStart*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isUpperCase*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE isWhitespace*(p0 : CHAR) : BOOLEAN;
                     PROCEDURE toLowerCase*(p0 : CHAR) : CHAR;
                     PROCEDURE toTitleCase*(p0 : CHAR) : CHAR;
                     PROCEDURE toUpperCase*(p0 : CHAR) : CHAR;
                   END;

      Class* = POINTER TO RECORD (Object + java_io.Serializable)
               STATIC
                 PROCEDURE forName*(p0 : String) : Class;
                 PROCEDURE forName*(p0 : String;
                                    p1 : BOOLEAN;
                                    p2 : ClassLoader) : Class;
               END;

      ClassCastException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                            STATIC
                              PROCEDURE Init*() : ClassCastException,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : String) : ClassCastException,CONSTRUCTOR;
                            END;

      ClassCircularityError* = POINTER TO EXTENSIBLE RECORD (LinkageError)
                               STATIC
                                 PROCEDURE Init*() : ClassCircularityError,CONSTRUCTOR;
                                 PROCEDURE Init*(p0 : String) : ClassCircularityError,CONSTRUCTOR;
                               END;

      ClassFormatError* = POINTER TO EXTENSIBLE RECORD (LinkageError)
                          STATIC
                            PROCEDURE Init*() : ClassFormatError,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : String) : ClassFormatError,CONSTRUCTOR;
                          END;

      ClassLoader* = POINTER TO ABSTRACT RECORD (Object)
                     STATIC
                       PROCEDURE Init!() : ClassLoader,CONSTRUCTOR;
                       PROCEDURE Init!(p0 : ClassLoader) : ClassLoader,CONSTRUCTOR;
                       PROCEDURE getSystemClassLoader*() : ClassLoader;
                       PROCEDURE getSystemResource*(p0 : String) : java_net.URL;
                       PROCEDURE getSystemResourceAsStream*(p0 : String) : java_io.InputStream;
                       PROCEDURE getSystemResources*(p0 : String) : java_util.Enumeration;
                     END;

      ClassNotFoundException* = POINTER TO EXTENSIBLE RECORD (Exception)
                                STATIC
                                  PROCEDURE Init*() : ClassNotFoundException,CONSTRUCTOR;
                                  PROCEDURE Init*(p0 : String) : ClassNotFoundException,CONSTRUCTOR;
                                  PROCEDURE Init*(p0 : String;
                                                  p1 : Throwable) : ClassNotFoundException,CONSTRUCTOR;
                                END;

      Cloneable* = POINTER TO INTERFACE RECORD (Object)
                   END;

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

      Comparable* = POINTER TO INTERFACE RECORD (Object)
                    END;

      Compiler* = POINTER TO RECORD (Object)
                  STATIC
                    PROCEDURE command*(p0 : Object) : Object;
                    PROCEDURE compileClass*(p0 : Class) : BOOLEAN;
                    PROCEDURE compileClasses*(p0 : String) : BOOLEAN;
                    PROCEDURE disable*();
                    PROCEDURE enable*();
                  END;

      Double* = POINTER TO RECORD (Number + Comparable)
                STATIC
                  POSITIVE_INFINITY* = Infinity;
                  NEGATIVE_INFINITY* = -Infinity;
                  NaN* = NaN;
                  MAX_VALUE* = 1.7976931348623157E308;
                  MIN_VALUE* : REAL;
                  TYPE* : Class;
                  PROCEDURE Init*(p0 : REAL) : Double,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : String) : Double,CONSTRUCTOR;
                  PROCEDURE doubleToLongBits*(p0 : REAL) : LONGINT;
                  PROCEDURE isInfinite*(p0 : REAL) : BOOLEAN;
                  PROCEDURE isNaN*(p0 : REAL) : BOOLEAN;
                  PROCEDURE longBitsToDouble*(p0 : LONGINT) : REAL;
                  PROCEDURE parseDouble*(p0 : String) : REAL;
                  PROCEDURE toString*(p0 : REAL) : String;
                  PROCEDURE valueOf*(p0 : String) : Double;
                END;

      Error* = POINTER TO EXTENSIBLE RECORD (Throwable)
               STATIC
                 PROCEDURE Init*() : Error,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : String) : Error,CONSTRUCTOR;
               END;

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

      ExceptionInInitializerError* = POINTER TO EXTENSIBLE RECORD (LinkageError)
                                     STATIC
                                       PROCEDURE Init*() : ExceptionInInitializerError,CONSTRUCTOR;
                                       PROCEDURE Init*(p0 : String) : ExceptionInInitializerError,CONSTRUCTOR;
                                       PROCEDURE Init*(p0 : Throwable) : ExceptionInInitializerError,CONSTRUCTOR;
                                     END;

      Float* = POINTER TO RECORD (Number + Comparable)
               STATIC
                 POSITIVE_INFINITY* = Infinity;
                 NEGATIVE_INFINITY* = -Infinity;
                 NaN* = NaN;
                 MAX_VALUE* = 3.4028234663852886E38;
                 MIN_VALUE* = 1.401298464324817E-45;
                 TYPE* : Class;
                 PROCEDURE Init*(p0 : REAL) : Float,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : SHORTREAL) : Float,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : String) : Float,CONSTRUCTOR;
                 PROCEDURE floatToIntBits*(p0 : SHORTREAL) : INTEGER;
                 PROCEDURE intBitsToFloat*(p0 : INTEGER) : SHORTREAL;
                 PROCEDURE isInfinite*(p0 : SHORTREAL) : BOOLEAN;
                 PROCEDURE isNaN*(p0 : SHORTREAL) : BOOLEAN;
                 PROCEDURE parseFloat*(p0 : String) : SHORTREAL;
                 PROCEDURE toString*(p0 : SHORTREAL) : String;
                 PROCEDURE valueOf*(p0 : String) : Float;
               END;

      IllegalAccessError* = POINTER TO EXTENSIBLE RECORD (IncompatibleClassChangeError)
                            STATIC
                              PROCEDURE Init*() : IllegalAccessError,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : String) : IllegalAccessError,CONSTRUCTOR;
                            END;

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

      IllegalArgumentException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                                  STATIC
                                    PROCEDURE Init*() : IllegalArgumentException,CONSTRUCTOR;
                                    PROCEDURE Init*(p0 : String) : IllegalArgumentException,CONSTRUCTOR;
                                  END;

      IllegalMonitorStateException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                                      STATIC
                                        PROCEDURE Init*() : IllegalMonitorStateException,CONSTRUCTOR;
                                        PROCEDURE Init*(p0 : String) : IllegalMonitorStateException,CONSTRUCTOR;
                                      END;

      IllegalStateException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                               STATIC
                                 PROCEDURE Init*() : IllegalStateException,CONSTRUCTOR;
                                 PROCEDURE Init*(p0 : String) : IllegalStateException,CONSTRUCTOR;
                               END;

      IllegalThreadStateException* = POINTER TO EXTENSIBLE RECORD (IllegalArgumentException)
                                     STATIC
                                       PROCEDURE Init*() : IllegalThreadStateException,CONSTRUCTOR;
                                       PROCEDURE Init*(p0 : String) : IllegalThreadStateException,CONSTRUCTOR;
                                     END;

      IncompatibleClassChangeError* = POINTER TO EXTENSIBLE RECORD (LinkageError)
                                      STATIC
                                        PROCEDURE Init*() : IncompatibleClassChangeError,CONSTRUCTOR;
                                        PROCEDURE Init*(p0 : String) : IncompatibleClassChangeError,CONSTRUCTOR;
                                      END;

      IndexOutOfBoundsException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                                   STATIC
                                     PROCEDURE Init*() : IndexOutOfBoundsException,CONSTRUCTOR;
                                     PROCEDURE Init*(p0 : String) : IndexOutOfBoundsException,CONSTRUCTOR;
                                   END;

      InheritableThreadLocal* = POINTER TO EXTENSIBLE RECORD (ThreadLocal)
                                STATIC
                                  PROCEDURE Init*() : InheritableThreadLocal,CONSTRUCTOR;
                                END;

      InstantiationError* = POINTER TO EXTENSIBLE RECORD (IncompatibleClassChangeError)
                            STATIC
                              PROCEDURE Init*() : InstantiationError,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : String) : InstantiationError,CONSTRUCTOR;
                            END;

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

      Integer* = POINTER TO RECORD (Number + Comparable)
                 STATIC
                   MIN_VALUE* = -2147483648;
                   MAX_VALUE* = 2147483647;
                   TYPE* : Class;
                   PROCEDURE Init*(p0 : INTEGER) : Integer,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : String) : Integer,CONSTRUCTOR;
                   PROCEDURE decode*(p0 : String) : Integer;
                   PROCEDURE getInteger*(p0 : String) : Integer;
                   PROCEDURE getInteger*(p0 : String;
                                         p1 : INTEGER) : Integer;
                   PROCEDURE getInteger*(p0 : String;
                                         p1 : Integer) : Integer;
                   PROCEDURE parseInt*(p0 : String) : INTEGER;
                   PROCEDURE parseInt*(p0 : String;
                                       p1 : INTEGER) : INTEGER;
                   PROCEDURE toBinaryString*(p0 : INTEGER) : String;
                   PROCEDURE toHexString*(p0 : INTEGER) : String;
                   PROCEDURE toOctalString*(p0 : INTEGER) : String;
                   PROCEDURE toString*(p0 : INTEGER) : String;
                   PROCEDURE toString*(p0 : INTEGER;
                                       p1 : INTEGER) : String;
                   PROCEDURE valueOf*(p0 : String) : Integer;
                   PROCEDURE valueOf*(p0 : String;
                                      p1 : INTEGER) : Integer;
                 END;

      InternalError* = POINTER TO EXTENSIBLE RECORD (VirtualMachineError)
                       STATIC
                         PROCEDURE Init*() : InternalError,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : String) : InternalError,CONSTRUCTOR;
                       END;

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

      LinkageError* = POINTER TO EXTENSIBLE RECORD (Error)
                      STATIC
                        PROCEDURE Init*() : LinkageError,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : String) : LinkageError,CONSTRUCTOR;
                      END;

      Long* = POINTER TO RECORD (Number + Comparable)
              STATIC
                MIN_VALUE* = -9223372036854775808;
                MAX_VALUE* = 9223372036854775807;
                TYPE* : Class;
                PROCEDURE Init*(p0 : LONGINT) : Long,CONSTRUCTOR;
                PROCEDURE Init*(p0 : String) : Long,CONSTRUCTOR;
                PROCEDURE decode*(p0 : String) : Long;
                PROCEDURE getLong*(p0 : String) : Long;
                PROCEDURE getLong*(p0 : String;
                                   p1 : LONGINT) : Long;
                PROCEDURE getLong*(p0 : String;
                                   p1 : Long) : Long;
                PROCEDURE parseLong*(p0 : String) : LONGINT;
                PROCEDURE parseLong*(p0 : String;
                                     p1 : INTEGER) : LONGINT;
                PROCEDURE toBinaryString*(p0 : LONGINT) : String;
                PROCEDURE toHexString*(p0 : LONGINT) : String;
                PROCEDURE toOctalString*(p0 : LONGINT) : String;
                PROCEDURE toString*(p0 : LONGINT) : String;
                PROCEDURE toString*(p0 : LONGINT;
                                    p1 : INTEGER) : String;
                PROCEDURE valueOf*(p0 : String) : Long;
                PROCEDURE valueOf*(p0 : String;
                                   p1 : INTEGER) : Long;
              END;

      Math* = POINTER TO RECORD (Object)
              STATIC
                E* = 2.718281828459045;
                PI* = 3.141592653589793;
                PROCEDURE IEEEremainder*(p0 : REAL;
                                         p1 : REAL) : REAL;
                PROCEDURE abs*(p0 : REAL) : REAL;
                PROCEDURE abs*(p0 : SHORTREAL) : SHORTREAL;
                PROCEDURE abs*(p0 : INTEGER) : INTEGER;
                PROCEDURE abs*(p0 : LONGINT) : LONGINT;
                PROCEDURE acos*(p0 : REAL) : REAL;
                PROCEDURE asin*(p0 : REAL) : REAL;
                PROCEDURE atan*(p0 : REAL) : REAL;
                PROCEDURE atan2*(p0 : REAL;
                                 p1 : REAL) : REAL;
                PROCEDURE ceil*(p0 : REAL) : REAL;
                PROCEDURE cos*(p0 : REAL) : REAL;
                PROCEDURE exp*(p0 : REAL) : REAL;
                PROCEDURE floor*(p0 : REAL) : REAL;
                PROCEDURE log*(p0 : REAL) : REAL;
                PROCEDURE max*(p0 : REAL;
                               p1 : REAL) : REAL;
                PROCEDURE max*(p0 : SHORTREAL;
                               p1 : SHORTREAL) : SHORTREAL;
                PROCEDURE max*(p0 : INTEGER;
                               p1 : INTEGER) : INTEGER;
                PROCEDURE max*(p0 : LONGINT;
                               p1 : LONGINT) : LONGINT;
                PROCEDURE min*(p0 : REAL;
                               p1 : REAL) : REAL;
                PROCEDURE min*(p0 : SHORTREAL;
                               p1 : SHORTREAL) : SHORTREAL;
                PROCEDURE min*(p0 : INTEGER;
                               p1 : INTEGER) : INTEGER;
                PROCEDURE min*(p0 : LONGINT;
                               p1 : LONGINT) : LONGINT;
                PROCEDURE pow*(p0 : REAL;
                               p1 : REAL) : REAL;
                PROCEDURE random*() : REAL;
                PROCEDURE rint*(p0 : REAL) : REAL;
                PROCEDURE round*(p0 : REAL) : LONGINT;
                PROCEDURE round*(p0 : SHORTREAL) : INTEGER;
                PROCEDURE sin*(p0 : REAL) : REAL;
                PROCEDURE sqrt*(p0 : REAL) : REAL;
                PROCEDURE tan*(p0 : REAL) : REAL;
                PROCEDURE toDegrees*(p0 : REAL) : REAL;
                PROCEDURE toRadians*(p0 : REAL) : REAL;
              END;

      NegativeArraySizeException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                                    STATIC
                                      PROCEDURE Init*() : NegativeArraySizeException,CONSTRUCTOR;
                                      PROCEDURE Init*(p0 : String) : NegativeArraySizeException,CONSTRUCTOR;
                                    END;

      NoClassDefFoundError* = POINTER TO EXTENSIBLE RECORD (LinkageError)
                              STATIC
                                PROCEDURE Init*() : NoClassDefFoundError,CONSTRUCTOR;
                                PROCEDURE Init*(p0 : String) : NoClassDefFoundError,CONSTRUCTOR;
                              END;

      NoSuchFieldError* = POINTER TO EXTENSIBLE RECORD (IncompatibleClassChangeError)
                          STATIC
                            PROCEDURE Init*() : NoSuchFieldError,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : String) : NoSuchFieldError,CONSTRUCTOR;
                          END;

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

      NoSuchMethodError* = POINTER TO EXTENSIBLE RECORD (IncompatibleClassChangeError)
                           STATIC
                             PROCEDURE Init*() : NoSuchMethodError,CONSTRUCTOR;
                             PROCEDURE Init*(p0 : String) : NoSuchMethodError,CONSTRUCTOR;
                           END;

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

      NullPointerException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                              STATIC
                                PROCEDURE Init*() : NullPointerException,CONSTRUCTOR;
                                PROCEDURE Init*(p0 : String) : NullPointerException,CONSTRUCTOR;
                              END;

      Number* = POINTER TO ABSTRACT RECORD (Object + java_io.Serializable)
                STATIC
                  PROCEDURE Init*() : Number,CONSTRUCTOR;
                END;

      NumberFormatException* = POINTER TO EXTENSIBLE RECORD (IllegalArgumentException)
                               STATIC
                                 PROCEDURE Init*() : NumberFormatException,CONSTRUCTOR;
                                 PROCEDURE Init*(p0 : String) : NumberFormatException,CONSTRUCTOR;
                               END;

      Object* = POINTER TO EXTENSIBLE RECORD
                STATIC
                  PROCEDURE Init*() : Object,CONSTRUCTOR;
                END;

      OutOfMemoryError* = POINTER TO EXTENSIBLE RECORD (VirtualMachineError)
                          STATIC
                            PROCEDURE Init*() : OutOfMemoryError,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : String) : OutOfMemoryError,CONSTRUCTOR;
                          END;

      Package* = POINTER TO EXTENSIBLE RECORD (Object)
                 STATIC
                   PROCEDURE getPackage*(p0 : String) : Package;
                   PROCEDURE getPackages*() : POINTER TO ARRAY OF Package;
                 END;

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

      Runnable* = POINTER TO INTERFACE RECORD (Object)
                  END;

      Runtime* = POINTER TO EXTENSIBLE RECORD (Object)
                 STATIC
                   PROCEDURE getRuntime*() : Runtime;
                   PROCEDURE runFinalizersOnExit*(p0 : BOOLEAN);
                 END;

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

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

      SecurityException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                           STATIC
                             PROCEDURE Init*() : SecurityException,CONSTRUCTOR;
                             PROCEDURE Init*(p0 : String) : SecurityException,CONSTRUCTOR;
                           END;

      SecurityManager* = POINTER TO EXTENSIBLE RECORD (Object)
                           inCheck! : BOOLEAN;
                         STATIC
                           PROCEDURE Init*() : SecurityManager,CONSTRUCTOR;
                         END;

      Short* = POINTER TO RECORD (Number + KeyListener)
               STATIC
                 MIN_VALUE* = -32768;
                 MAX_VALUE* = 32767;
                 TYPE* : Class;
                 PROCEDURE Init*(p0 : String) : Short,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : SHORTINT) : Short,CONSTRUCTOR;
                 PROCEDURE decode*(p0 : String) : Short;
                 PROCEDURE parseShort*(p0 : String) : SHORTINT;
                 PROCEDURE parseShort*(p0 : String;
                                       p1 : INTEGER) : SHORTINT;
                 PROCEDURE toString*(p0 : SHORTINT) : String;
                 PROCEDURE valueOf*(p0 : String) : Short;
                 PROCEDURE valueOf*(p0 : String;
                                    p1 : INTEGER) : Short;
               END;

      StackOverflowError* = POINTER TO EXTENSIBLE RECORD (VirtualMachineError)
                            STATIC
                              PROCEDURE Init*() : StackOverflowError,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : String) : StackOverflowError,CONSTRUCTOR;
                            END;

      String* = POINTER TO RECORD (Object + java_io.Serializable + KeyListener)
                STATIC
                  CASE_INSENSITIVE_ORDER* : java_util.Comparator;
                  PROCEDURE Init*() : String,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : String) : String,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : StringBuffer) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF BYTE) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                      p1 : INTEGER) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                      p1 : INTEGER;
                                      p2 : INTEGER) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                      p1 : INTEGER;
                                      p2 : INTEGER;
                                      p3 : INTEGER) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                      p1 : INTEGER;
                                      p2 : INTEGER;
                                      p3 : String) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                      p1 : String) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF CHAR) : String,CONSTRUCTOR;
                  PROCEDURE Init*(IN  p0 : ARRAY OF CHAR;
                                      p1 : INTEGER;
                                      p2 : INTEGER) : String,CONSTRUCTOR;
                  PROCEDURE copyValueOf*(IN  p0 : ARRAY OF CHAR) : String;
                  PROCEDURE copyValueOf*(IN  p0 : ARRAY OF CHAR;
                                             p1 : INTEGER;
                                             p2 : INTEGER) : String;
                  PROCEDURE valueOf*(p0 : CHAR) : String;
                  PROCEDURE valueOf*(p0 : REAL) : String;
                  PROCEDURE valueOf*(p0 : SHORTREAL) : String;
                  PROCEDURE valueOf*(p0 : INTEGER) : String;
                  PROCEDURE valueOf*(p0 : LONGINT) : String;
                  PROCEDURE valueOf*(p0 : Object) : String;
                  PROCEDURE valueOf*(p0 : BOOLEAN) : String;
                  PROCEDURE valueOf*(IN  p0 : ARRAY OF CHAR) : String;
                  PROCEDURE valueOf*(IN  p0 : ARRAY OF CHAR;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : String;
                END;

      StringBuffer* = POINTER TO RECORD (Object + java_io.Serializable)
                      STATIC
                        PROCEDURE Init*() : StringBuffer,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : INTEGER) : StringBuffer,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : String) : StringBuffer,CONSTRUCTOR;
                      END;

      StringIndexOutOfBoundsException* = POINTER TO EXTENSIBLE RECORD (IndexOutOfBoundsException)
                                         STATIC
                                           PROCEDURE Init*() : StringIndexOutOfBoundsException,CONSTRUCTOR;
                                           PROCEDURE Init*(p0 : INTEGER) : StringIndexOutOfBoundsException,CONSTRUCTOR;
                                           PROCEDURE Init*(p0 : String) : StringIndexOutOfBoundsException,CONSTRUCTOR;
                                         END;

      System* = POINTER TO RECORD (Object)
                STATIC
                  in* : java_io.InputStream;
                  out* : java_io.PrintStream;
                  err* : java_io.PrintStream;
                  PROCEDURE arraycopy*(p0 : Object;
                                       p1 : INTEGER;
                                       p2 : Object;
                                       p3 : INTEGER;
                                       p4 : INTEGER);
                  PROCEDURE currentTimeMillis*() : LONGINT;
                  PROCEDURE exit*(p0 : INTEGER);
                  PROCEDURE gc*();
                  PROCEDURE getProperties*() : java_util.Properties;
                  PROCEDURE getProperty*(p0 : String) : String;
                  PROCEDURE getProperty*(p0 : String;
                                         p1 : String) : String;
                  PROCEDURE getSecurityManager*() : SecurityManager;
                  PROCEDURE getenv*(p0 : String) : String;
                  PROCEDURE identityHashCode*(p0 : Object) : INTEGER;
                  PROCEDURE load*(p0 : String);
                  PROCEDURE loadLibrary*(p0 : String);
                  PROCEDURE mapLibraryName*(p0 : String) : String;
                  PROCEDURE runFinalization*();
                  PROCEDURE runFinalizersOnExit*(p0 : BOOLEAN);
                  PROCEDURE setErr*(p0 : java_io.PrintStream);
                  PROCEDURE setIn*(p0 : java_io.InputStream);
                  PROCEDURE setOut*(p0 : java_io.PrintStream);
                  PROCEDURE setProperties*(p0 : java_util.Properties);
                  PROCEDURE setProperty*(p0 : String;
                                         p1 : String) : String;
                  PROCEDURE setSecurityManager*(p0 : SecurityManager);
                END;

      Thread* = POINTER TO EXTENSIBLE RECORD (Object + Runnable)
                STATIC
                  MIN_PRIORITY* = 1;
                  NORM_PRIORITY* = 5;
                  MAX_PRIORITY* = 10;
                  PROCEDURE Init*() : Thread,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : Runnable) : Thread,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : Runnable;
                                  p1 : String) : Thread,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : String) : Thread,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : ThreadGroup;
                                  p1 : Runnable) : Thread,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : ThreadGroup;
                                  p1 : Runnable;
                                  p2 : String) : Thread,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : ThreadGroup;
                                  p1 : String) : Thread,CONSTRUCTOR;
                  PROCEDURE activeCount*() : INTEGER;
                  PROCEDURE currentThread*() : Thread;
                  PROCEDURE dumpStack*();
                  PROCEDURE enumerate*(IN  p0 : ARRAY OF Thread) : INTEGER;
                  PROCEDURE interrupted*() : BOOLEAN;
                  PROCEDURE sleep*(p0 : LONGINT);
                  PROCEDURE sleep*(p0 : LONGINT;
                                   p1 : INTEGER);
                  PROCEDURE yield*();
                END;

      ThreadDeath* = POINTER TO EXTENSIBLE RECORD (Error)
                     STATIC
                       PROCEDURE Init*() : ThreadDeath,CONSTRUCTOR;
                     END;

      ThreadGroup* = POINTER TO EXTENSIBLE RECORD (Object)
                     STATIC
                       PROCEDURE Init*(p0 : String) : ThreadGroup,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : ThreadGroup;
                                       p1 : String) : ThreadGroup,CONSTRUCTOR;
                     END;

      ThreadLocal* = POINTER TO EXTENSIBLE RECORD (Object)
                     STATIC
                       PROCEDURE Init*() : ThreadLocal,CONSTRUCTOR;
                     END;

      Throwable* = POINTER TO EXTENSIBLE RECORD (Object + java_io.Serializable)
                   STATIC
                     PROCEDURE Init*() : Throwable,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : String) : Throwable,CONSTRUCTOR;
                   END;

      UnknownError* = POINTER TO EXTENSIBLE RECORD (VirtualMachineError)
                      STATIC
                        PROCEDURE Init*() : UnknownError,CONSTRUCTOR;
                        PROCEDURE Init*(p0 : String) : UnknownError,CONSTRUCTOR;
                      END;

      UnsatisfiedLinkError* = POINTER TO EXTENSIBLE RECORD (LinkageError)
                              STATIC
                                PROCEDURE Init*() : UnsatisfiedLinkError,CONSTRUCTOR;
                                PROCEDURE Init*(p0 : String) : UnsatisfiedLinkError,CONSTRUCTOR;
                              END;

      UnsupportedClassVersionError* = POINTER TO EXTENSIBLE RECORD (ClassFormatError)
                                      STATIC
                                        PROCEDURE Init*() : UnsupportedClassVersionError,CONSTRUCTOR;
                                        PROCEDURE Init*(p0 : String) : UnsupportedClassVersionError,CONSTRUCTOR;
                                      END;

      UnsupportedOperationException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)
                                       STATIC
                                         PROCEDURE Init*() : UnsupportedOperationException,CONSTRUCTOR;
                                         PROCEDURE Init*(p0 : String) : UnsupportedOperationException,CONSTRUCTOR;
                                       END;

      VerifyError* = POINTER TO EXTENSIBLE RECORD (LinkageError)
                     STATIC
                       PROCEDURE Init*() : VerifyError,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : String) : VerifyError,CONSTRUCTOR;
                     END;

      VirtualMachineError* = POINTER TO ABSTRACT RECORD (Error)
                             STATIC
                               PROCEDURE Init*() : VirtualMachineError,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : String) : VirtualMachineError,CONSTRUCTOR;
                             END;

      Void* = POINTER TO RECORD (Object)
              STATIC
                TYPE* : Class;
              END;

    PROCEDURE (self:Boolean) booleanValue*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Boolean) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

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

    PROCEDURE (self:Boolean) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:Byte) byteValue*() : BYTE,EXTENSIBLE;

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

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

    PROCEDURE (self:Byte) doubleValue*() : REAL,EXTENSIBLE;

    PROCEDURE (self:Byte) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:Byte) floatValue*() : SHORTREAL,EXTENSIBLE;

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

    PROCEDURE (self:Byte) intValue*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:Byte) longValue*() : LONGINT,EXTENSIBLE;

    PROCEDURE (self:Byte) shortValue*() : SHORTINT,EXTENSIBLE;

    PROCEDURE (self:Byte) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:Character$Subset) equals*(p0 : Object) : BOOLEAN;

    PROCEDURE (self:Character$Subset) hashCode*() : INTEGER;

    PROCEDURE (self:Character$Subset) toString*() : String;

    PROCEDURE (self:Character) charValue*() : CHAR,NEW,EXTENSIBLE;

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

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

    PROCEDURE (self:Character) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

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

    PROCEDURE (self:Character) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:Class) getClassLoader*() : ClassLoader,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getClasses*() : POINTER TO ARRAY OF Class,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getComponentType*() : Class,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getConstructor*(IN  p0 : ARRAY OF Class) : java_lang_reflect.Constructor,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getConstructors*() : POINTER TO ARRAY OF java_lang_reflect.Constructor,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaredClasses*() : POINTER TO ARRAY OF Class,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaredConstructor*(IN  p0 : ARRAY OF Class) : java_lang_reflect.Constructor,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaredConstructors*() : POINTER TO ARRAY OF java_lang_reflect.Constructor,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaredField*(p0 : String) : java_lang_reflect.Field,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaredFields*() : POINTER TO ARRAY OF java_lang_reflect.Field,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaredMethod*(    p0 : String;
                                              IN  p1 : ARRAY OF Class) : java_lang_reflect.Method,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaredMethods*() : POINTER TO ARRAY OF java_lang_reflect.Method,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getDeclaringClass*() : Class,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getField*(p0 : String) : java_lang_reflect.Field,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getFields*() : POINTER TO ARRAY OF java_lang_reflect.Field,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getInterfaces*() : POINTER TO ARRAY OF Class,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getMethod*(    p0 : String;
                                      IN  p1 : ARRAY OF Class) : java_lang_reflect.Method,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getMethods*() : POINTER TO ARRAY OF java_lang_reflect.Method,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getModifiers*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getName*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getPackage*() : Package,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getProtectionDomain*() : java_security.ProtectionDomain,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getResource*(p0 : String) : java_net.URL,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getResourceAsStream*(p0 : String) : java_io.InputStream,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getSigners*() : POINTER TO ARRAY OF Object,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) getSuperclass*() : Class,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) isArray*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) isAssignableFrom*(p0 : Class) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) isInstance*(p0 : Object) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) isInterface*() : BOOLEAN,NEW,EXTENSIBLE;

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

    PROCEDURE (self:Class) newInstance*() : Object,NEW,EXTENSIBLE;

    PROCEDURE (self:Class) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) defineClass!(    p0 : String;
                                              IN  p1 : ARRAY OF BYTE;
                                                  p2 : INTEGER;
                                                  p3 : INTEGER) : Class,NEW;

    PROCEDURE (self:ClassLoader) defineClass!(    p0 : String;
                                              IN  p1 : ARRAY OF BYTE;
                                                  p2 : INTEGER;
                                                  p3 : INTEGER;
                                                  p4 : java_security.ProtectionDomain) : Class,NEW;

    PROCEDURE (self:ClassLoader) defineClass!(IN  p0 : ARRAY OF BYTE;
                                                  p1 : INTEGER;
                                                  p2 : INTEGER) : Class,NEW;

    PROCEDURE (self:ClassLoader) definePackage!(p0 : String;
                                                p1 : String;
                                                p2 : String;
                                                p3 : String;
                                                p4 : String;
                                                p5 : String;
                                                p6 : String;
                                                p7 : java_net.URL) : Package,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) findClass!(p0 : String) : Class,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) findLibrary!(p0 : String) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) findLoadedClass!(p0 : String) : Class,NEW;

    PROCEDURE (self:ClassLoader) findResource!(p0 : String) : java_net.URL,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) findResources!(p0 : String) : java_util.Enumeration,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) findSystemClass!(p0 : String) : Class,NEW;

    PROCEDURE (self:ClassLoader) getPackage!(p0 : String) : Package,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) getPackages!() : POINTER TO ARRAY OF Package,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) getParent*() : ClassLoader,NEW;

    PROCEDURE (self:ClassLoader) getResource*(p0 : String) : java_net.URL,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) getResourceAsStream*(p0 : String) : java_io.InputStream,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) getResources*(p0 : String) : java_util.Enumeration,NEW;

    PROCEDURE (self:ClassLoader) loadClass*(p0 : String) : Class,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) loadClass!(p0 : String;
                                            p1 : BOOLEAN) : Class,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassLoader) resolveClass!(p0 : Class),NEW;

    PROCEDURE (self:ClassLoader) setSigners!(    p0 : Class;
                                             IN  p1 : ARRAY OF Object),NEW;

    PROCEDURE (self:ClassNotFoundException) getException*() : Throwable,NEW,EXTENSIBLE;

    PROCEDURE (self:ClassNotFoundException) printStackTrace*(),EXTENSIBLE;

    PROCEDURE (self:ClassNotFoundException) printStackTrace*(p0 : java_io.PrintStream),EXTENSIBLE;

    PROCEDURE (self:ClassNotFoundException) printStackTrace*(p0 : java_io.PrintWriter),EXTENSIBLE;

    PROCEDURE (self:Comparable) compareTo*(p0 : Object) : INTEGER,NEW,ABSTRACT;

    PROCEDURE (self:Double) byteValue*() : BYTE,EXTENSIBLE;

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

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

    PROCEDURE (self:Double) doubleValue*() : REAL,EXTENSIBLE;

    PROCEDURE (self:Double) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:Double) floatValue*() : SHORTREAL,EXTENSIBLE;

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

    PROCEDURE (self:Double) intValue*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:Double) isInfinite*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Double) isNaN*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Double) longValue*() : LONGINT,EXTENSIBLE;

    PROCEDURE (self:Double) shortValue*() : SHORTINT,EXTENSIBLE;

    PROCEDURE (self:Double) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:ExceptionInInitializerError) getException*() : Throwable,NEW,EXTENSIBLE;

    PROCEDURE (self:ExceptionInInitializerError) printStackTrace*(),EXTENSIBLE;

    PROCEDURE (self:ExceptionInInitializerError) printStackTrace*(p0 : java_io.PrintStream),EXTENSIBLE;

    PROCEDURE (self:ExceptionInInitializerError) printStackTrace*(p0 : java_io.PrintWriter),EXTENSIBLE;

    PROCEDURE (self:Float) byteValue*() : BYTE,EXTENSIBLE;

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

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

    PROCEDURE (self:Float) doubleValue*() : REAL,EXTENSIBLE;

    PROCEDURE (self:Float) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:Float) floatValue*() : SHORTREAL,EXTENSIBLE;

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

    PROCEDURE (self:Float) intValue*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:Float) isInfinite*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Float) isNaN*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Float) longValue*() : LONGINT,EXTENSIBLE;

    PROCEDURE (self:Float) shortValue*() : SHORTINT,EXTENSIBLE;

    PROCEDURE (self:Float) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:InheritableThreadLocal) childValue!(p0 : Object) : Object,NEW,EXTENSIBLE;

    PROCEDURE (self:Integer) byteValue*() : BYTE,EXTENSIBLE;

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

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

    PROCEDURE (self:Integer) doubleValue*() : REAL,EXTENSIBLE;

    PROCEDURE (self:Integer) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:Integer) floatValue*() : SHORTREAL,EXTENSIBLE;

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

    PROCEDURE (self:Integer) intValue*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:Integer) longValue*() : LONGINT,EXTENSIBLE;

    PROCEDURE (self:Integer) shortValue*() : SHORTINT,EXTENSIBLE;

    PROCEDURE (self:Integer) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:Long) byteValue*() : BYTE,EXTENSIBLE;

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

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

    PROCEDURE (self:Long) doubleValue*() : REAL,EXTENSIBLE;

    PROCEDURE (self:Long) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:Long) floatValue*() : SHORTREAL,EXTENSIBLE;

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

    PROCEDURE (self:Long) intValue*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:Long) longValue*() : LONGINT,EXTENSIBLE;

    PROCEDURE (self:Long) shortValue*() : SHORTINT,EXTENSIBLE;

    PROCEDURE (self:Long) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:Number) byteValue*() : BYTE,NEW,EXTENSIBLE;

    PROCEDURE (self:Number) doubleValue*() : REAL,NEW,ABSTRACT;

    PROCEDURE (self:Number) floatValue*() : SHORTREAL,NEW,ABSTRACT;

    PROCEDURE (self:Number) intValue*() : INTEGER,NEW,ABSTRACT;

    PROCEDURE (self:Number) longValue*() : LONGINT,NEW,ABSTRACT;

    PROCEDURE (self:Number) shortValue*() : SHORTINT,NEW,EXTENSIBLE;

    PROCEDURE (self:Object) clone!() : Object,NEW,EXTENSIBLE;

    PROCEDURE (self:Object) equals*(p0 : Object) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Object) finalize!(),NEW,EXTENSIBLE;

    PROCEDURE (self:Object) getClass*() : Class,NEW;

    PROCEDURE (self:Object) hashCode*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:Object) notify*(),NEW;

    PROCEDURE (self:Object) notifyAll*(),NEW;

    PROCEDURE (self:Object) toString*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Object) wait*(),NEW;

    PROCEDURE (self:Object) wait*(p0 : LONGINT),NEW;

    PROCEDURE (self:Object) wait*(p0 : LONGINT;
                                  p1 : INTEGER),NEW;

    PROCEDURE (self:Package) getImplementationTitle*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) getImplementationVendor*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) getImplementationVersion*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) getName*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) getSpecificationTitle*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) getSpecificationVendor*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) getSpecificationVersion*() : String,NEW,EXTENSIBLE;

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

    PROCEDURE (self:Package) isCompatibleWith*(p0 : String) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) isSealed*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) isSealed*(p0 : java_net.URL) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Package) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:Process) destroy*(),NEW,ABSTRACT;

    PROCEDURE (self:Process) exitValue*() : INTEGER,NEW,ABSTRACT;

    PROCEDURE (self:Process) getErrorStream*() : java_io.InputStream,NEW,ABSTRACT;

    PROCEDURE (self:Process) getInputStream*() : java_io.InputStream,NEW,ABSTRACT;

    PROCEDURE (self:Process) getOutputStream*() : java_io.OutputStream,NEW,ABSTRACT;

    PROCEDURE (self:Process) waitFor*() : INTEGER,NEW,ABSTRACT;

    PROCEDURE (self:Runnable) run*(),NEW,ABSTRACT;

    PROCEDURE (self:Runtime) exec*(p0 : String) : Process,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) exec*(    p0 : String;
                                   IN  p1 : ARRAY OF String) : Process,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) exec*(IN  p0 : ARRAY OF String) : Process,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) exec*(IN  p0 : ARRAY OF String;
                                   IN  p1 : ARRAY OF String) : Process,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) exit*(p0 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) freeMemory*() : LONGINT,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) gc*(),NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) getLocalizedInputStream*(p0 : java_io.InputStream) : java_io.InputStream,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) getLocalizedOutputStream*(p0 : java_io.OutputStream) : java_io.OutputStream,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) load*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) loadLibrary*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) runFinalization*(),NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) totalMemory*() : LONGINT,NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) traceInstructions*(p0 : BOOLEAN),NEW,EXTENSIBLE;

    PROCEDURE (self:Runtime) traceMethodCalls*(p0 : BOOLEAN),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkAccept*(p0 : String;
                                                  p1 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkAccess*(p0 : Thread),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkAccess*(p0 : ThreadGroup),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkAwtEventQueueAccess*(),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkConnect*(p0 : String;
                                                   p1 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkConnect*(p0 : String;
                                                   p1 : INTEGER;
                                                   p2 : Object),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkCreateClassLoader*(),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkDelete*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkExec*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkExit*(p0 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkLink*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkListen*(p0 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkMemberAccess*(p0 : Class;
                                                        p1 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkMulticast*(p0 : java_net.InetAddress),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkMulticast*(p0 : java_net.InetAddress;
                                                     p1 : BYTE),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkPackageAccess*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkPackageDefinition*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkPermission*(p0 : java_security.Permission),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkPermission*(p0 : java_security.Permission;
                                                      p1 : Object),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkPrintJobAccess*(),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkPropertiesAccess*(),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkPropertyAccess*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkRead*(p0 : java_io.FileDescriptor),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkRead*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkRead*(p0 : String;
                                                p1 : Object),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkSecurityAccess*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkSetFactory*(),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkSystemClipboardAccess*(),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkTopLevelWindow*(p0 : Object) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkWrite*(p0 : java_io.FileDescriptor),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) checkWrite*(p0 : String),NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) classDepth!(p0 : String) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) classLoaderDepth!() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) currentClassLoader!() : ClassLoader,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) currentLoadedClass!() : Class,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) getClassContext!() : POINTER TO ARRAY OF Class,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) getInCheck*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) getSecurityContext*() : Object,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) getThreadGroup*() : ThreadGroup,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) inClass!(p0 : String) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:SecurityManager) inClassLoader!() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Short) byteValue*() : BYTE,EXTENSIBLE;

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

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

    PROCEDURE (self:Short) doubleValue*() : REAL,EXTENSIBLE;

    PROCEDURE (self:Short) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:Short) floatValue*() : SHORTREAL,EXTENSIBLE;

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

    PROCEDURE (self:Short) intValue*() : INTEGER,EXTENSIBLE;

    PROCEDURE (self:Short) longValue*() : LONGINT,EXTENSIBLE;

    PROCEDURE (self:Short) shortValue*() : SHORTINT,EXTENSIBLE;

    PROCEDURE (self:Short) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:String) charAt*(p0 : INTEGER) : CHAR,NEW,EXTENSIBLE;

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

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

    PROCEDURE (self:String) compareToIgnoreCase*(p0 : String) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) concat*(p0 : String) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) endsWith*(p0 : String) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:String) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

    PROCEDURE (self:String) equalsIgnoreCase*(p0 : String) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:String) getBytes*() : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

    PROCEDURE (self:String) getBytes*(    p0 : INTEGER;
                                          p1 : INTEGER;
                                      IN  p2 : ARRAY OF BYTE;
                                          p3 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:String) getBytes*(p0 : String) : POINTER TO ARRAY OF BYTE,NEW,EXTENSIBLE;

    PROCEDURE (self:String) getChars*(    p0 : INTEGER;
                                          p1 : INTEGER;
                                      IN  p2 : ARRAY OF CHAR;
                                          p3 : INTEGER),NEW,EXTENSIBLE;

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

    PROCEDURE (self:String) indexOf*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) indexOf*(p0 : INTEGER;
                                     p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) indexOf*(p0 : String) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) indexOf*(p0 : String;
                                     p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) intern*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) lastIndexOf*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) lastIndexOf*(p0 : INTEGER;
                                         p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) lastIndexOf*(p0 : String) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) lastIndexOf*(p0 : String;
                                         p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) length*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:String) regionMatches*(p0 : INTEGER;
                                           p1 : String;
                                           p2 : INTEGER;
                                           p3 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:String) regionMatches*(p0 : BOOLEAN;
                                           p1 : INTEGER;
                                           p2 : String;
                                           p3 : INTEGER;
                                           p4 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:String) replace*(p0 : CHAR;
                                     p1 : CHAR) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) startsWith*(p0 : String) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:String) startsWith*(p0 : String;
                                        p1 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:String) substring*(p0 : INTEGER) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) substring*(p0 : INTEGER;
                                       p1 : INTEGER) : String,NEW,EXTENSIBLE;

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

    PROCEDURE (self:String) toLowerCase*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) toLowerCase*(p0 : java_util.Locale) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:String) toUpperCase*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) toUpperCase*(p0 : java_util.Locale) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:String) trim*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : CHAR) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : REAL) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : SHORTREAL) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : INTEGER) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : LONGINT) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : Object) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : String) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(p0 : BOOLEAN) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) append*(IN  p0 : ARRAY OF CHAR) : StringBuffer,NEW,EXTENSIBLE;

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

    PROCEDURE (self:StringBuffer) capacity*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) charAt*(p0 : INTEGER) : CHAR,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) delete*(p0 : INTEGER;
                                          p1 : INTEGER) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) deleteCharAt*(p0 : INTEGER) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) ensureCapacity*(p0 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) getChars*(    p0 : INTEGER;
                                                p1 : INTEGER;
                                            IN  p2 : ARRAY OF CHAR;
                                                p3 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : CHAR) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : REAL) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : SHORTREAL) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : INTEGER) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : LONGINT) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : Object) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : String) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                          p1 : BOOLEAN) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(    p0 : INTEGER;
                                          IN  p1 : ARRAY OF CHAR) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) insert*(    p0 : INTEGER;
                                          IN  p1 : ARRAY OF CHAR;
                                              p2 : INTEGER;
                                              p3 : INTEGER) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) length*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) replace*(p0 : INTEGER;
                                           p1 : INTEGER;
                                           p2 : String) : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) reverse*() : StringBuffer,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) setCharAt*(p0 : INTEGER;
                                             p1 : CHAR),NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) setLength*(p0 : INTEGER),NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) substring*(p0 : INTEGER) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) substring*(p0 : INTEGER;
                                             p1 : INTEGER) : String,NEW,EXTENSIBLE;

    PROCEDURE (self:StringBuffer) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:Thread) checkAccess*(),NEW;

    PROCEDURE (self:Thread) countStackFrames*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) destroy*(),NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) getContextClassLoader*() : ClassLoader,NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) getName*() : String,NEW;

    PROCEDURE (self:Thread) getPriority*() : INTEGER,NEW;

    PROCEDURE (self:Thread) getThreadGroup*() : ThreadGroup,NEW;

    PROCEDURE (self:Thread) interrupt*(),NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) isAlive*() : BOOLEAN,NEW;

    PROCEDURE (self:Thread) isDaemon*() : BOOLEAN,NEW;

    PROCEDURE (self:Thread) isInterrupted*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) join*(),NEW;

    PROCEDURE (self:Thread) join*(p0 : LONGINT),NEW;

    PROCEDURE (self:Thread) join*(p0 : LONGINT;
                                  p1 : INTEGER),NEW;

    PROCEDURE (self:Thread) resume*(),NEW;

    PROCEDURE (self:Thread) run*(),NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) setContextClassLoader*(p0 : ClassLoader),NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) setDaemon*(p0 : BOOLEAN),NEW;

    PROCEDURE (self:Thread) setName*(p0 : String),NEW;

    PROCEDURE (self:Thread) setPriority*(p0 : INTEGER),NEW;

    PROCEDURE (self:Thread) start*(),NEW,EXTENSIBLE;

    PROCEDURE (self:Thread) stop*(),NEW;

    PROCEDURE (self:Thread) stop*(p0 : Throwable),NEW;

    PROCEDURE (self:Thread) suspend*(),NEW;

    PROCEDURE (self:Thread) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) activeCount*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) activeGroupCount*() : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) allowThreadSuspension*(p0 : BOOLEAN) : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) checkAccess*(),NEW;

    PROCEDURE (self:ThreadGroup) destroy*(),NEW;

    PROCEDURE (self:ThreadGroup) enumerate*(IN  p0 : ARRAY OF Thread) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) enumerate*(IN  p0 : ARRAY OF Thread;
                                                p1 : BOOLEAN) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) enumerate*(IN  p0 : ARRAY OF ThreadGroup) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) enumerate*(IN  p0 : ARRAY OF ThreadGroup;
                                                p1 : BOOLEAN) : INTEGER,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) getMaxPriority*() : INTEGER,NEW;

    PROCEDURE (self:ThreadGroup) getName*() : String,NEW;

    PROCEDURE (self:ThreadGroup) getParent*() : ThreadGroup,NEW;

    PROCEDURE (self:ThreadGroup) interrupt*(),NEW;

    PROCEDURE (self:ThreadGroup) isDaemon*() : BOOLEAN,NEW;

    PROCEDURE (self:ThreadGroup) isDestroyed*() : BOOLEAN,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) list*(),NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) parentOf*(p0 : ThreadGroup) : BOOLEAN,NEW;

    PROCEDURE (self:ThreadGroup) resume*(),NEW;

    PROCEDURE (self:ThreadGroup) setDaemon*(p0 : BOOLEAN),NEW;

    PROCEDURE (self:ThreadGroup) setMaxPriority*(p0 : INTEGER),NEW;

    PROCEDURE (self:ThreadGroup) stop*(),NEW;

    PROCEDURE (self:ThreadGroup) suspend*(),NEW;

    PROCEDURE (self:ThreadGroup) toString*() : String,EXTENSIBLE;

    PROCEDURE (self:ThreadGroup) uncaughtException*(p0 : Thread;
                                                    p1 : Throwable),NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadLocal) get*() : Object,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadLocal) initialValue!() : Object,NEW,EXTENSIBLE;

    PROCEDURE (self:ThreadLocal) set*(p0 : Object),NEW,EXTENSIBLE;

    PROCEDURE (self:Throwable) fillInStackTrace*() : Throwable,NEW,EXTENSIBLE;

    PROCEDURE (self:Throwable) getLocalizedMessage*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Throwable) getMessage*() : String,NEW,EXTENSIBLE;

    PROCEDURE (self:Throwable) printStackTrace*(),NEW,EXTENSIBLE;

    PROCEDURE (self:Throwable) printStackTrace*(p0 : java_io.PrintStream),NEW,EXTENSIBLE;

    PROCEDURE (self:Throwable) printStackTrace*(p0 : java_io.PrintWriter),NEW,EXTENSIBLE;

    PROCEDURE (self:Throwable) toString*() : String,EXTENSIBLE;

    END java_lang.