FOREIGN MODULE java_lang;

IMPORT
    java_io := "java.io",
    java_util := "java.util",
    java_security := "java.security",
    java_lang_reflect := "java.lang.reflect",
    java_lang_ref := "java.lang.ref",
    sun_reflect_generics_repository := "sun.reflect.generics.repository",
    sun_reflect := "sun.reflect",
    sun_reflect_annotation := "sun.reflect.annotation",
    java_net := "java.net",
    sun_reflect_generics_factory := "sun.reflect.generics.factory",
    java_lang_annotation := "java.lang.annotation",
    java_nio := "java.nio",
    sun_misc := "sun.misc",
    java_util_concurrent_atomic := "java.util.concurrent.atomic",
    java_util_jar := "java.util.jar",
    java_nio_charset := "java.nio.charset",
    sun_nio_ch := "sun.nio.ch",
    java_nio_channels := "java.nio.channels";

TYPE

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

  Appendable* = POINTER TO INTERFACE RECORD (Object)    (* Typebound Procedures *)
                END;

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

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

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

  AssertionError* = POINTER TO EXTENSIBLE RECORD (Error)
                    STATIC
                      PROCEDURE Init*(p0 : LONGINT) : AssertionError,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : INTEGER) : AssertionError,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : REAL) : AssertionError,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : SHORTREAL) : AssertionError,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : Object) : AssertionError,CONSTRUCTOR;
                      PROCEDURE Init*() : AssertionError,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : CHAR) : AssertionError,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : BOOLEAN) : AssertionError,CONSTRUCTOR;
                    END;

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

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

  Character* = POINTER TO RECORD (Object + java_io.Serializable + Comparable)    (* Typebound Procedures *)
               STATIC
                 COMBINING_SPACING_MARK*                    = 8;
                 CONNECTOR_PUNCTUATION*                     = 23;
                 CONTROL*                                   = 15;
                 CURRENCY_SYMBOL*                           = 26;
                 DASH_PUNCTUATION*                          = 20;
                 DECIMAL_DIGIT_NUMBER*                      = 9;
                 DIRECTIONALITY_ARABIC_NUMBER*              = 6;
                 DIRECTIONALITY_BOUNDARY_NEUTRAL*           = 9;
                 DIRECTIONALITY_COMMON_NUMBER_SEPARATOR*    = 7;
                 DIRECTIONALITY_EUROPEAN_NUMBER*            = 3;
                 DIRECTIONALITY_EUROPEAN_NUMBER_SEPARATOR*  = 4;
                 DIRECTIONALITY_EUROPEAN_NUMBER_TERMINATOR* = 5;
                 DIRECTIONALITY_LEFT_TO_RIGHT*              = 0;
                 DIRECTIONALITY_LEFT_TO_RIGHT_EMBEDDING*    = 14;
                 DIRECTIONALITY_LEFT_TO_RIGHT_OVERRIDE*     = 15;
                 DIRECTIONALITY_NONSPACING_MARK*            = 8;
                 DIRECTIONALITY_OTHER_NEUTRALS*             = 13;
                 DIRECTIONALITY_PARAGRAPH_SEPARATOR*        = 10;
                 DIRECTIONALITY_POP_DIRECTIONAL_FORMAT*     = 18;
                 DIRECTIONALITY_RIGHT_TO_LEFT*              = 1;
                 DIRECTIONALITY_RIGHT_TO_LEFT_ARABIC*       = 2;
                 DIRECTIONALITY_RIGHT_TO_LEFT_EMBEDDING*    = 16;
                 DIRECTIONALITY_RIGHT_TO_LEFT_OVERRIDE*     = 17;
                 DIRECTIONALITY_SEGMENT_SEPARATOR*          = 11;
                 DIRECTIONALITY_UNDEFINED*                  = -1;
                 DIRECTIONALITY_WHITESPACE*                 = 12;
                 ENCLOSING_MARK*                            = 7;
                 END_PUNCTUATION*                           = 22;
                 FINAL_QUOTE_PUNCTUATION*                   = 30;
                 FORMAT*                                    = 16;
                 INITIAL_QUOTE_PUNCTUATION*                 = 29;
                 LETTER_NUMBER*                             = 10;
                 LINE_SEPARATOR*                            = 13;
                 LOWERCASE_LETTER*                          = 2;
                 MATH_SYMBOL*                               = 25;
                 MAX_CODE_POINT*                            = 1114111;
                 MAX_HIGH_SURROGATE*                        = 56319;
                 MAX_LOW_SURROGATE*                         = 57343;
                 MAX_RADIX*                                 = 36;
                 MAX_SURROGATE*                             = 57343;
                 MAX_VALUE*                                 = 65535;
                 MIN_CODE_POINT*                            = 0;
                 MIN_HIGH_SURROGATE*                        = 55296;
                 MIN_LOW_SURROGATE*                         = 56320;
                 MIN_RADIX*                                 = 2;
                 MIN_SUPPLEMENTARY_CODE_POINT*              = 65536;
                 MIN_SURROGATE*                             = 55296;
                 MIN_VALUE*                                 = 0;
                 MODIFIER_LETTER*                           = 4;
                 MODIFIER_SYMBOL*                           = 27;
                 NON_SPACING_MARK*                          = 6;
                 OTHER_LETTER*                              = 5;
                 OTHER_NUMBER*                              = 11;
                 OTHER_PUNCTUATION*                         = 24;
                 OTHER_SYMBOL*                              = 28;
                 PARAGRAPH_SEPARATOR*                       = 14;
                 PRIVATE_USE*                               = 18;
                 SIZE*                                      = 16;
                 SPACE_SEPARATOR*                           = 12;
                 START_PUNCTUATION*                         = 21;
                 SURROGATE*                                 = 19;
                 TITLECASE_LETTER*                          = 3;
                 TYPE*                                      : Class;
                 UNASSIGNED*                                = 0;
                 UPPERCASE_LETTER*                          = 1;
                 PROCEDURE charCount*(p0 : INTEGER) : INTEGER;
                 PROCEDURE codePointAt*(p0 : CharSequence;
                                        p1 : INTEGER) : INTEGER;
                 PROCEDURE codePointAt*(IN  p0 : ARRAY OF CHAR;
                                            p1 : INTEGER) : INTEGER;
                 PROCEDURE codePointAt*(IN  p0 : ARRAY OF CHAR;
                                            p1 : INTEGER;
                                            p2 : INTEGER) : INTEGER;
                 PROCEDURE codePointBefore*(IN  p0 : ARRAY OF CHAR;
                                                p1 : INTEGER;
                                                p2 : INTEGER) : INTEGER;
                 PROCEDURE codePointBefore*(p0 : CharSequence;
                                            p1 : INTEGER) : INTEGER;
                 PROCEDURE codePointBefore*(IN  p0 : ARRAY OF CHAR;
                                                p1 : INTEGER) : INTEGER;
                 PROCEDURE codePointCount*(IN  p0 : ARRAY OF CHAR;
                                               p1 : INTEGER;
                                               p2 : INTEGER) : INTEGER;
                 PROCEDURE codePointCount*(p0 : CharSequence;
                                           p1 : INTEGER;
                                           p2 : INTEGER) : INTEGER;
                 PROCEDURE digit*(p0 : CHAR;
                                  p1 : INTEGER) : INTEGER;
                 PROCEDURE digit*(p0 : INTEGER;
                                  p1 : INTEGER) : INTEGER;
                 PROCEDURE forDigit*(p0 : INTEGER;
                                     p1 : INTEGER) : CHAR;
                 PROCEDURE getDirectionality*(p0 : INTEGER) : BYTE;
                 PROCEDURE getDirectionality*(p0 : CHAR) : BYTE;
                 PROCEDURE getNumericValue*(p0 : CHAR) : INTEGER;
                 PROCEDURE getNumericValue*(p0 : INTEGER) : INTEGER;
                 PROCEDURE getType*(p0 : CHAR) : INTEGER;
                 PROCEDURE getType*(p0 : INTEGER) : INTEGER;
                 PROCEDURE Init*(p0 : CHAR) : Character,CONSTRUCTOR;
                 PROCEDURE isDefined*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isDefined*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isDigit*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isDigit*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isHighSurrogate*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isIdentifierIgnorable*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isIdentifierIgnorable*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isISOControl*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isISOControl*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isJavaIdentifierPart*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isJavaIdentifierPart*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isJavaIdentifierStart*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isJavaIdentifierStart*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isJavaLetter*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isJavaLetterOrDigit*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isLetter*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isLetter*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isLetterOrDigit*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isLetterOrDigit*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isLowerCase*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isLowerCase*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isLowSurrogate*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isMirrored*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isMirrored*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isSpace*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isSpaceChar*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isSpaceChar*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isSupplementaryCodePoint*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isSurrogatePair*(p0 : CHAR;
                                            p1 : CHAR) : BOOLEAN;
                 PROCEDURE isTitleCase*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isTitleCase*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isUnicodeIdentifierPart*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isUnicodeIdentifierPart*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isUnicodeIdentifierStart*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isUnicodeIdentifierStart*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isUpperCase*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isUpperCase*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isValidCodePoint*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE isWhitespace*(p0 : CHAR) : BOOLEAN;
                 PROCEDURE isWhitespace*(p0 : INTEGER) : BOOLEAN;
                 PROCEDURE offsetByCodePoints*(IN  p0 : ARRAY OF CHAR;
                                                   p1 : INTEGER;
                                                   p2 : INTEGER;
                                                   p3 : INTEGER;
                                                   p4 : INTEGER) : INTEGER;
                 PROCEDURE offsetByCodePoints*(p0 : CharSequence;
                                               p1 : INTEGER;
                                               p2 : INTEGER) : INTEGER;
                 PROCEDURE reverseBytes*(p0 : CHAR) : CHAR;
                 PROCEDURE toChars*(p0 : INTEGER) : POINTER TO ARRAY OF CHAR;
                 PROCEDURE toChars*(    p0 : INTEGER;
                                    IN  p1 : ARRAY OF CHAR;
                                        p2 : INTEGER) : INTEGER;
                 PROCEDURE toCodePoint*(p0 : CHAR;
                                        p1 : CHAR) : INTEGER;
                 PROCEDURE toLowerCase*(p0 : INTEGER) : INTEGER;
                 PROCEDURE toLowerCase*(p0 : CHAR) : CHAR;
                 PROCEDURE toString*(p0 : CHAR) : String;
                 PROCEDURE toTitleCase*(p0 : CHAR) : CHAR;
                 PROCEDURE toTitleCase*(p0 : INTEGER) : INTEGER;
                 PROCEDURE toUpperCase*(p0 : CHAR) : CHAR;
                 PROCEDURE toUpperCase*(p0 : INTEGER) : INTEGER;
                 PROCEDURE valueOf*(p0 : CHAR) : Character;
               END;

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

  Character$UnicodeBlock* = POINTER TO RECORD (Character$Subset)
                            STATIC
                              AEGEAN_NUMBERS*                          : Character$UnicodeBlock;
                              ALPHABETIC_PRESENTATION_FORMS*           : Character$UnicodeBlock;
                              ARABIC*                                  : Character$UnicodeBlock;
                              ARABIC_PRESENTATION_FORMS_A*             : Character$UnicodeBlock;
                              ARABIC_PRESENTATION_FORMS_B*             : Character$UnicodeBlock;
                              ARMENIAN*                                : Character$UnicodeBlock;
                              ARROWS*                                  : Character$UnicodeBlock;
                              BASIC_LATIN*                             : Character$UnicodeBlock;
                              BENGALI*                                 : Character$UnicodeBlock;
                              BLOCK_ELEMENTS*                          : Character$UnicodeBlock;
                              BOPOMOFO*                                : Character$UnicodeBlock;
                              BOPOMOFO_EXTENDED*                       : Character$UnicodeBlock;
                              BOX_DRAWING*                             : Character$UnicodeBlock;
                              BRAILLE_PATTERNS*                        : Character$UnicodeBlock;
                              BUHID*                                   : Character$UnicodeBlock;
                              BYZANTINE_MUSICAL_SYMBOLS*               : Character$UnicodeBlock;
                              CHEROKEE*                                : Character$UnicodeBlock;
                              CJK_COMPATIBILITY*                       : Character$UnicodeBlock;
                              CJK_COMPATIBILITY_FORMS*                 : Character$UnicodeBlock;
                              CJK_COMPATIBILITY_IDEOGRAPHS*            : Character$UnicodeBlock;
                              CJK_COMPATIBILITY_IDEOGRAPHS_SUPPLEMENT* : Character$UnicodeBlock;
                              CJK_RADICALS_SUPPLEMENT*                 : Character$UnicodeBlock;
                              CJK_SYMBOLS_AND_PUNCTUATION*             : Character$UnicodeBlock;
                              CJK_UNIFIED_IDEOGRAPHS*                  : Character$UnicodeBlock;
                              CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A*      : Character$UnicodeBlock;
                              CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B*      : Character$UnicodeBlock;
                              COMBINING_DIACRITICAL_MARKS*             : Character$UnicodeBlock;
                              COMBINING_HALF_MARKS*                    : Character$UnicodeBlock;
                              COMBINING_MARKS_FOR_SYMBOLS*             : Character$UnicodeBlock;
                              CONTROL_PICTURES*                        : Character$UnicodeBlock;
                              CURRENCY_SYMBOLS*                        : Character$UnicodeBlock;
                              CYPRIOT_SYLLABARY*                       : Character$UnicodeBlock;
                              CYRILLIC*                                : Character$UnicodeBlock;
                              CYRILLIC_SUPPLEMENTARY*                  : Character$UnicodeBlock;
                              DESERET*                                 : Character$UnicodeBlock;
                              DEVANAGARI*                              : Character$UnicodeBlock;
                              DINGBATS*                                : Character$UnicodeBlock;
                              ENCLOSED_ALPHANUMERICS*                  : Character$UnicodeBlock;
                              ENCLOSED_CJK_LETTERS_AND_MONTHS*         : Character$UnicodeBlock;
                              ETHIOPIC*                                : Character$UnicodeBlock;
                              GENERAL_PUNCTUATION*                     : Character$UnicodeBlock;
                              GEOMETRIC_SHAPES*                        : Character$UnicodeBlock;
                              GEORGIAN*                                : Character$UnicodeBlock;
                              GOTHIC*                                  : Character$UnicodeBlock;
                              GREEK*                                   : Character$UnicodeBlock;
                              GREEK_EXTENDED*                          : Character$UnicodeBlock;
                              GUJARATI*                                : Character$UnicodeBlock;
                              GURMUKHI*                                : Character$UnicodeBlock;
                              HALFWIDTH_AND_FULLWIDTH_FORMS*           : Character$UnicodeBlock;
                              HANGUL_COMPATIBILITY_JAMO*               : Character$UnicodeBlock;
                              HANGUL_JAMO*                             : Character$UnicodeBlock;
                              HANGUL_SYLLABLES*                        : Character$UnicodeBlock;
                              HANUNOO*                                 : Character$UnicodeBlock;
                              HEBREW*                                  : Character$UnicodeBlock;
                              HIGH_PRIVATE_USE_SURROGATES*             : Character$UnicodeBlock;
                              HIGH_SURROGATES*                         : Character$UnicodeBlock;
                              HIRAGANA*                                : Character$UnicodeBlock;
                              IDEOGRAPHIC_DESCRIPTION_CHARACTERS*      : Character$UnicodeBlock;
                              IPA_EXTENSIONS*                          : Character$UnicodeBlock;
                              KANBUN*                                  : Character$UnicodeBlock;
                              KANGXI_RADICALS*                         : Character$UnicodeBlock;
                              KANNADA*                                 : Character$UnicodeBlock;
                              KATAKANA*                                : Character$UnicodeBlock;
                              KATAKANA_PHONETIC_EXTENSIONS*            : Character$UnicodeBlock;
                              KHMER*                                   : Character$UnicodeBlock;
                              KHMER_SYMBOLS*                           : Character$UnicodeBlock;
                              LAO*                                     : Character$UnicodeBlock;
                              LATIN_1_SUPPLEMENT*                      : Character$UnicodeBlock;
                              LATIN_EXTENDED_A*                        : Character$UnicodeBlock;
                              LATIN_EXTENDED_ADDITIONAL*               : Character$UnicodeBlock;
                              LATIN_EXTENDED_B*                        : Character$UnicodeBlock;
                              LETTERLIKE_SYMBOLS*                      : Character$UnicodeBlock;
                              LIMBU*                                   : Character$UnicodeBlock;
                              LINEAR_B_IDEOGRAMS*                      : Character$UnicodeBlock;
                              LINEAR_B_SYLLABARY*                      : Character$UnicodeBlock;
                              LOW_SURROGATES*                          : Character$UnicodeBlock;
                              MALAYALAM*                               : Character$UnicodeBlock;
                              MATHEMATICAL_ALPHANUMERIC_SYMBOLS*       : Character$UnicodeBlock;
                              MATHEMATICAL_OPERATORS*                  : Character$UnicodeBlock;
                              MISCELLANEOUS_MATHEMATICAL_SYMBOLS_A*    : Character$UnicodeBlock;
                              MISCELLANEOUS_MATHEMATICAL_SYMBOLS_B*    : Character$UnicodeBlock;
                              MISCELLANEOUS_SYMBOLS*                   : Character$UnicodeBlock;
                              MISCELLANEOUS_SYMBOLS_AND_ARROWS*        : Character$UnicodeBlock;
                              MISCELLANEOUS_TECHNICAL*                 : Character$UnicodeBlock;
                              MONGOLIAN*                               : Character$UnicodeBlock;
                              MUSICAL_SYMBOLS*                         : Character$UnicodeBlock;
                              MYANMAR*                                 : Character$UnicodeBlock;
                              NUMBER_FORMS*                            : Character$UnicodeBlock;
                              OGHAM*                                   : Character$UnicodeBlock;
                              OLD_ITALIC*                              : Character$UnicodeBlock;
                              OPTICAL_CHARACTER_RECOGNITION*           : Character$UnicodeBlock;
                              ORIYA*                                   : Character$UnicodeBlock;
                              OSMANYA*                                 : Character$UnicodeBlock;
                              PHONETIC_EXTENSIONS*                     : Character$UnicodeBlock;
                              PRIVATE_USE_AREA*                        : Character$UnicodeBlock;
                              RUNIC*                                   : Character$UnicodeBlock;
                              SHAVIAN*                                 : Character$UnicodeBlock;
                              SINHALA*                                 : Character$UnicodeBlock;
                              SMALL_FORM_VARIANTS*                     : Character$UnicodeBlock;
                              SPACING_MODIFIER_LETTERS*                : Character$UnicodeBlock;
                              SPECIALS*                                : Character$UnicodeBlock;
                              SUPERSCRIPTS_AND_SUBSCRIPTS*             : Character$UnicodeBlock;
                              SUPPLEMENTAL_ARROWS_A*                   : Character$UnicodeBlock;
                              SUPPLEMENTAL_ARROWS_B*                   : Character$UnicodeBlock;
                              SUPPLEMENTAL_MATHEMATICAL_OPERATORS*     : Character$UnicodeBlock;
                              SUPPLEMENTARY_PRIVATE_USE_AREA_A*        : Character$UnicodeBlock;
                              SUPPLEMENTARY_PRIVATE_USE_AREA_B*        : Character$UnicodeBlock;
                              SURROGATES_AREA*                         : Character$UnicodeBlock;
                              SYRIAC*                                  : Character$UnicodeBlock;
                              TAGALOG*                                 : Character$UnicodeBlock;
                              TAGBANWA*                                : Character$UnicodeBlock;
                              TAGS*                                    : Character$UnicodeBlock;
                              TAI_LE*                                  : Character$UnicodeBlock;
                              TAI_XUAN_JING_SYMBOLS*                   : Character$UnicodeBlock;
                              TAMIL*                                   : Character$UnicodeBlock;
                              TELUGU*                                  : Character$UnicodeBlock;
                              THAANA*                                  : Character$UnicodeBlock;
                              THAI*                                    : Character$UnicodeBlock;
                              TIBETAN*                                 : Character$UnicodeBlock;
                              UGARITIC*                                : Character$UnicodeBlock;
                              UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS*   : Character$UnicodeBlock;
                              VARIATION_SELECTORS*                     : Character$UnicodeBlock;
                              VARIATION_SELECTORS_SUPPLEMENT*          : Character$UnicodeBlock;
                              YIJING_HEXAGRAM_SYMBOLS*                 : Character$UnicodeBlock;
                              YI_RADICALS*                             : Character$UnicodeBlock;
                              YI_SYLLABLES*                            : Character$UnicodeBlock;
                              PROCEDURE forName*(p0 : String) : Character$UnicodeBlock;
                              PROCEDURE of*(p0 : INTEGER) : Character$UnicodeBlock;
                              PROCEDURE of*(p0 : CHAR) : Character$UnicodeBlock;
                            END;

  CharSequence* = POINTER TO INTERFACE RECORD (Object)    (* Typebound Procedures *)
                  END;

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

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

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

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

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

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

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

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

  Comparable* = POINTER TO INTERFACE RECORD (Object)    (* Typebound Procedures *)
                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;

  Deprecated* = POINTER TO INTERFACE RECORD (Object + java_lang_annotation.Annotation)
                END;

  Double* = POINTER TO RECORD (Number + Comparable)    (* Typebound Procedures *)
            STATIC
              MAX_EXPONENT*        = 1023;
              MAX_VALUE*           = 1.7976931348623157E308;
              MIN_EXPONENT*        = -1022;
              MIN_NORMAL*          = 2.2250738585072014E-308;
              MIN_VALUE*           = 4.9E-324;
              NaN*                 = NaN;
              NEGATIVE_INFINITY*   = -Infinity;
              POSITIVE_INFINITY*   = Infinity;
              SIZE*                = 64;
              TYPE*                : Class;
              PROCEDURE compare*(p0 : REAL;
                                 p1 : REAL) : INTEGER;
              PROCEDURE doubleToLongBits*(p0 : REAL) : LONGINT;
              PROCEDURE doubleToRawLongBits*(p0 : REAL) : LONGINT;
              PROCEDURE Init*(p0 : REAL) : Double,CONSTRUCTOR;
              PROCEDURE Init*(p0 : String) : Double,CONSTRUCTOR;
              PROCEDURE isInfinite*(p0 : REAL) : BOOLEAN;
              PROCEDURE isNaN*(p0 : REAL) : BOOLEAN;
              PROCEDURE longBitsToDouble*(p0 : LONGINT) : REAL;
              PROCEDURE parseDouble*(p0 : String) : REAL;
              PROCEDURE toHexString*(p0 : REAL) : String;
              PROCEDURE toString*(p0 : REAL) : String;
              PROCEDURE valueOf*(p0 : REAL) : Double;
              PROCEDURE valueOf*(p0 : String) : Double;
            END;

  Enum* = POINTER TO ABSTRACT RECORD (Object + Comparable + java_io.Serializable)    (* Typebound Procedures *)
          STATIC
            PROCEDURE Init!(p0 : String;
                            p1 : INTEGER) : Enum,CONSTRUCTOR;
            PROCEDURE valueOf*(p0 : Class;
                               p1 : String) : Enum;
          END;

  EnumConstantNotPresentException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)    (* Typebound Procedures *)
                                     STATIC
                                       PROCEDURE Init*(p0 : Class;
                                                       p1 : String) : EnumConstantNotPresentException,CONSTRUCTOR;
                                     END;

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

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

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

  Float* = POINTER TO RECORD (Number + Comparable)    (* Typebound Procedures *)
           STATIC
             MAX_EXPONENT*      = 127;
             MAX_VALUE*         = 3.4028234663852886E38;
             MIN_EXPONENT*      = -126;
             MIN_NORMAL*        = 1.1754943508222875E-38;
             MIN_VALUE*         = 1.401298464324817E-45;
             NaN*               = NaN;
             NEGATIVE_INFINITY* = -Infinity;
             POSITIVE_INFINITY* = Infinity;
             SIZE*              = 32;
             TYPE*              : Class;
             PROCEDURE compare*(p0 : SHORTREAL;
                                p1 : SHORTREAL) : INTEGER;
             PROCEDURE floatToIntBits*(p0 : SHORTREAL) : INTEGER;
             PROCEDURE floatToRawIntBits*(p0 : SHORTREAL) : INTEGER;
             PROCEDURE Init*(p0 : REAL) : Float,CONSTRUCTOR;
             PROCEDURE Init*(p0 : SHORTREAL) : Float,CONSTRUCTOR;
             PROCEDURE Init*(p0 : String) : Float,CONSTRUCTOR;
             PROCEDURE intBitsToFloat*(p0 : INTEGER) : SHORTREAL;
             PROCEDURE isInfinite*(p0 : SHORTREAL) : BOOLEAN;
             PROCEDURE isNaN*(p0 : SHORTREAL) : BOOLEAN;
             PROCEDURE parseFloat*(p0 : String) : SHORTREAL;
             PROCEDURE toHexString*(p0 : SHORTREAL) : String;
             PROCEDURE toString*(p0 : SHORTREAL) : String;
             PROCEDURE valueOf*(p0 : SHORTREAL) : Float;
             PROCEDURE valueOf*(p0 : String) : Float;
           END;

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

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

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

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

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

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

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

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

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

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

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

  Integer* = POINTER TO RECORD (Number + Comparable)    (* Typebound Procedures *)
             STATIC
               MAX_VALUE*             = 2147483647;
               MIN_VALUE*             = -2147483648;
               SIZE*                  = 32;
               TYPE*                  : Class;
               PROCEDURE bitCount*(p0 : INTEGER) : INTEGER;
               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 highestOneBit*(p0 : INTEGER) : INTEGER;
               PROCEDURE Init*(p0 : INTEGER) : Integer,CONSTRUCTOR;
               PROCEDURE Init*(p0 : String) : Integer,CONSTRUCTOR;
               PROCEDURE lowestOneBit*(p0 : INTEGER) : INTEGER;
               PROCEDURE numberOfLeadingZeros*(p0 : INTEGER) : INTEGER;
               PROCEDURE numberOfTrailingZeros*(p0 : INTEGER) : INTEGER;
               PROCEDURE parseInt*(p0 : String;
                                   p1 : INTEGER) : INTEGER;
               PROCEDURE parseInt*(p0 : String) : INTEGER;
               PROCEDURE reverse*(p0 : INTEGER) : INTEGER;
               PROCEDURE reverseBytes*(p0 : INTEGER) : INTEGER;
               PROCEDURE rotateLeft*(p0 : INTEGER;
                                     p1 : INTEGER) : INTEGER;
               PROCEDURE rotateRight*(p0 : INTEGER;
                                      p1 : INTEGER) : INTEGER;
               PROCEDURE signum*(p0 : 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;
                                  p1 : INTEGER) : Integer;
               PROCEDURE valueOf*(p0 : String) : Integer;
               PROCEDURE valueOf*(p0 : INTEGER) : Integer;
             END;

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

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

  Iterable* = POINTER TO INTERFACE RECORD (Object)    (* Typebound Procedures *)
              END;

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

  Long* = POINTER TO RECORD (Number + Comparable)    (* Typebound Procedures *)
          STATIC
            MAX_VALUE*             = 9223372036854775807;
            MIN_VALUE*             = -9223372036854775808;
            SIZE*                  = 64;
            TYPE*                  : Class;
            PROCEDURE bitCount*(p0 : LONGINT) : INTEGER;
            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 highestOneBit*(p0 : LONGINT) : LONGINT;
            PROCEDURE Init*(p0 : LONGINT) : Long,CONSTRUCTOR;
            PROCEDURE Init*(p0 : String) : Long,CONSTRUCTOR;
            PROCEDURE lowestOneBit*(p0 : LONGINT) : LONGINT;
            PROCEDURE numberOfLeadingZeros*(p0 : LONGINT) : INTEGER;
            PROCEDURE numberOfTrailingZeros*(p0 : LONGINT) : INTEGER;
            PROCEDURE parseLong*(p0 : String;
                                 p1 : INTEGER) : LONGINT;
            PROCEDURE parseLong*(p0 : String) : LONGINT;
            PROCEDURE reverse*(p0 : LONGINT) : LONGINT;
            PROCEDURE reverseBytes*(p0 : LONGINT) : LONGINT;
            PROCEDURE rotateLeft*(p0 : LONGINT;
                                  p1 : INTEGER) : LONGINT;
            PROCEDURE rotateRight*(p0 : LONGINT;
                                   p1 : INTEGER) : LONGINT;
            PROCEDURE signum*(p0 : LONGINT) : INTEGER;
            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 : LONGINT) : Long;
            PROCEDURE valueOf*(p0 : String;
                               p1 : INTEGER) : Long;
          END;

  Math* = POINTER TO RECORD (Object)
          STATIC
            E*             = 2.718281828459045;
            PI*            = 3.141592653589793;
            PROCEDURE abs*(p0 : SHORTREAL) : SHORTREAL;
            PROCEDURE abs*(p0 : REAL) : REAL;
            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 cbrt*(p0 : REAL) : REAL;
            PROCEDURE ceil*(p0 : REAL) : REAL;
            PROCEDURE copySign*(p0 : SHORTREAL;
                                p1 : SHORTREAL) : SHORTREAL;
            PROCEDURE copySign*(p0 : REAL;
                                p1 : REAL) : REAL;
            PROCEDURE cos*(p0 : REAL) : REAL;
            PROCEDURE cosh*(p0 : REAL) : REAL;
            PROCEDURE exp*(p0 : REAL) : REAL;
            PROCEDURE expm1*(p0 : REAL) : REAL;
            PROCEDURE floor*(p0 : REAL) : REAL;
            PROCEDURE getExponent*(p0 : REAL) : INTEGER;
            PROCEDURE getExponent*(p0 : SHORTREAL) : INTEGER;
            PROCEDURE hypot*(p0 : REAL;
                             p1 : REAL) : REAL;
            PROCEDURE IEEEremainder*(p0 : REAL;
                                     p1 : REAL) : REAL;
            PROCEDURE log*(p0 : REAL) : REAL;
            PROCEDURE log10*(p0 : REAL) : REAL;
            PROCEDURE log1p*(p0 : REAL) : REAL;
            PROCEDURE max*(p0 : LONGINT;
                           p1 : LONGINT) : LONGINT;
            PROCEDURE max*(p0 : REAL;
                           p1 : REAL) : REAL;
            PROCEDURE max*(p0 : SHORTREAL;
                           p1 : SHORTREAL) : SHORTREAL;
            PROCEDURE max*(p0 : INTEGER;
                           p1 : INTEGER) : INTEGER;
            PROCEDURE min*(p0 : LONGINT;
                           p1 : LONGINT) : LONGINT;
            PROCEDURE min*(p0 : SHORTREAL;
                           p1 : SHORTREAL) : SHORTREAL;
            PROCEDURE min*(p0 : REAL;
                           p1 : REAL) : REAL;
            PROCEDURE min*(p0 : INTEGER;
                           p1 : INTEGER) : INTEGER;
            PROCEDURE nextAfter*(p0 : SHORTREAL;
                                 p1 : REAL) : SHORTREAL;
            PROCEDURE nextAfter*(p0 : REAL;
                                 p1 : REAL) : REAL;
            PROCEDURE nextUp*(p0 : SHORTREAL) : SHORTREAL;
            PROCEDURE nextUp*(p0 : REAL) : REAL;
            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 scalb*(p0 : SHORTREAL;
                             p1 : INTEGER) : SHORTREAL;
            PROCEDURE scalb*(p0 : REAL;
                             p1 : INTEGER) : REAL;
            PROCEDURE signum*(p0 : SHORTREAL) : SHORTREAL;
            PROCEDURE signum*(p0 : REAL) : REAL;
            PROCEDURE sin*(p0 : REAL) : REAL;
            PROCEDURE sinh*(p0 : REAL) : REAL;
            PROCEDURE sqrt*(p0 : REAL) : REAL;
            PROCEDURE tan*(p0 : REAL) : REAL;
            PROCEDURE tanh*(p0 : REAL) : REAL;
            PROCEDURE toDegrees*(p0 : REAL) : REAL;
            PROCEDURE toRadians*(p0 : REAL) : REAL;
            PROCEDURE ulp*(p0 : REAL) : REAL;
            PROCEDURE ulp*(p0 : SHORTREAL) : SHORTREAL;
          END;

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

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

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

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

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

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

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

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

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

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

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

  Override* = POINTER TO INTERFACE RECORD (Object + java_lang_annotation.Annotation)
              END;

  Package* = POINTER TO EXTENSIBLE RECORD (Object + java_lang_reflect.AnnotatedElement)    (* Typebound Procedures *)
             STATIC
               PROCEDURE getPackage*(p0 : String) : Package;
               PROCEDURE getPackages*() : POINTER TO ARRAY OF Package;
             END;

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

  ProcessBuilder* = POINTER TO RECORD (Object)    (* Typebound Procedures *)
                    STATIC
                      PROCEDURE Init*(IN  p0 : ARRAY OF String) : ProcessBuilder,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : java_util.List) : ProcessBuilder,CONSTRUCTOR;
                    END;

  Readable* = POINTER TO INTERFACE RECORD (Object)    (* Typebound Procedures *)
              END;

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

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

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

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

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

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

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

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

  StackTraceElement* = POINTER TO RECORD (Object + java_io.Serializable)    (* Typebound Procedures *)
                       STATIC
                         PROCEDURE Init*(p0 : String;
                                         p1 : String;
                                         p2 : String;
                                         p3 : INTEGER) : StackTraceElement,CONSTRUCTOR;
                       END;

  StrictMath* = POINTER TO RECORD (Object)
                STATIC
                  E*             = 2.718281828459045;
                  PI*            = 3.141592653589793;
                  PROCEDURE abs*(p0 : SHORTREAL) : SHORTREAL;
                  PROCEDURE abs*(p0 : REAL) : REAL;
                  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 cbrt*(p0 : REAL) : REAL;
                  PROCEDURE ceil*(p0 : REAL) : REAL;
                  PROCEDURE copySign*(p0 : SHORTREAL;
                                      p1 : SHORTREAL) : SHORTREAL;
                  PROCEDURE copySign*(p0 : REAL;
                                      p1 : REAL) : REAL;
                  PROCEDURE cos*(p0 : REAL) : REAL;
                  PROCEDURE cosh*(p0 : REAL) : REAL;
                  PROCEDURE exp*(p0 : REAL) : REAL;
                  PROCEDURE expm1*(p0 : REAL) : REAL;
                  PROCEDURE floor*(p0 : REAL) : REAL;
                  PROCEDURE getExponent*(p0 : REAL) : INTEGER;
                  PROCEDURE getExponent*(p0 : SHORTREAL) : INTEGER;
                  PROCEDURE hypot*(p0 : REAL;
                                   p1 : REAL) : REAL;
                  PROCEDURE IEEEremainder*(p0 : REAL;
                                           p1 : REAL) : REAL;
                  PROCEDURE log*(p0 : REAL) : REAL;
                  PROCEDURE log10*(p0 : REAL) : REAL;
                  PROCEDURE log1p*(p0 : REAL) : REAL;
                  PROCEDURE max*(p0 : LONGINT;
                                 p1 : LONGINT) : LONGINT;
                  PROCEDURE max*(p0 : REAL;
                                 p1 : REAL) : REAL;
                  PROCEDURE max*(p0 : SHORTREAL;
                                 p1 : SHORTREAL) : SHORTREAL;
                  PROCEDURE max*(p0 : INTEGER;
                                 p1 : INTEGER) : INTEGER;
                  PROCEDURE min*(p0 : LONGINT;
                                 p1 : LONGINT) : LONGINT;
                  PROCEDURE min*(p0 : SHORTREAL;
                                 p1 : SHORTREAL) : SHORTREAL;
                  PROCEDURE min*(p0 : REAL;
                                 p1 : REAL) : REAL;
                  PROCEDURE min*(p0 : INTEGER;
                                 p1 : INTEGER) : INTEGER;
                  PROCEDURE nextAfter*(p0 : SHORTREAL;
                                       p1 : REAL) : SHORTREAL;
                  PROCEDURE nextAfter*(p0 : REAL;
                                       p1 : REAL) : REAL;
                  PROCEDURE nextUp*(p0 : SHORTREAL) : SHORTREAL;
                  PROCEDURE nextUp*(p0 : REAL) : REAL;
                  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 scalb*(p0 : SHORTREAL;
                                   p1 : INTEGER) : SHORTREAL;
                  PROCEDURE scalb*(p0 : REAL;
                                   p1 : INTEGER) : REAL;
                  PROCEDURE signum*(p0 : SHORTREAL) : SHORTREAL;
                  PROCEDURE signum*(p0 : REAL) : REAL;
                  PROCEDURE sin*(p0 : REAL) : REAL;
                  PROCEDURE sinh*(p0 : REAL) : REAL;
                  PROCEDURE sqrt*(p0 : REAL) : REAL;
                  PROCEDURE tan*(p0 : REAL) : REAL;
                  PROCEDURE tanh*(p0 : REAL) : REAL;
                  PROCEDURE toDegrees*(p0 : REAL) : REAL;
                  PROCEDURE toRadians*(p0 : REAL) : REAL;
                  PROCEDURE ulp*(p0 : REAL) : REAL;
                  PROCEDURE ulp*(p0 : SHORTREAL) : SHORTREAL;
                END;

  String* = POINTER TO RECORD (Object + java_io.Serializable + Comparable + CharSequence)    (* Typebound Procedures *)
            STATIC
              CASE_INSENSITIVE_ORDER* : java_util.Comparator;
              PROCEDURE copyValueOf*(IN  p0 : ARRAY OF CHAR;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : String;
              PROCEDURE copyValueOf*(IN  p0 : ARRAY OF CHAR) : String;
              PROCEDURE format*(    p0 : String;
                                IN  p1 : ARRAY OF Object) : String;
              PROCEDURE format*(    p0 : java_util.Locale;
                                    p1 : String;
                                IN  p2 : ARRAY OF Object) : String;
              PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                  p1 : INTEGER;
                                  p2 : INTEGER) : String,CONSTRUCTOR;
              PROCEDURE Init*(IN  p0 : ARRAY OF BYTE;
                                  p1 : java_nio_charset.Charset) : String,CONSTRUCTOR;
              PROCEDURE Init*(IN  p0 : ARRAY OF BYTE) : String,CONSTRUCTOR;
              PROCEDURE Init*(p0 : StringBuilder) : String,CONSTRUCTOR;
              PROCEDURE Init*(p0 : StringBuffer) : 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 Init*() : String,CONSTRUCTOR;
              PROCEDURE Init*(p0 : String) : String,CONSTRUCTOR;
              PROCEDURE Init*(IN  p0 : ARRAY OF INTEGER;
                                  p1 : INTEGER;
                                  p2 : 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 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : java_nio_charset.Charset) : 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) : String,CONSTRUCTOR;
              PROCEDURE valueOf*(p0 : INTEGER) : String;
              PROCEDURE valueOf*(p0 : REAL) : String;
              PROCEDURE valueOf*(p0 : SHORTREAL) : String;
              PROCEDURE valueOf*(p0 : LONGINT) : String;
              PROCEDURE valueOf*(p0 : CHAR) : String;
              PROCEDURE valueOf*(IN  p0 : ARRAY OF CHAR) : String;
              PROCEDURE valueOf*(p0 : Object) : String;
              PROCEDURE valueOf*(p0 : BOOLEAN) : String;
              PROCEDURE valueOf*(IN  p0 : ARRAY OF CHAR;
                                     p1 : INTEGER;
                                     p2 : INTEGER) : String;
            END;

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

  StringBuilder* = POINTER TO RECORD (AbstractStringBuilder + java_io.Serializable + CharSequence)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*(p0 : String) : StringBuilder,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : CharSequence) : StringBuilder,CONSTRUCTOR;
                     PROCEDURE Init*() : StringBuilder,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER) : StringBuilder,CONSTRUCTOR;
                   END;

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

  SuppressWarnings* = POINTER TO INTERFACE RECORD (Object + java_lang_annotation.Annotation)    (* Typebound Procedures *)
                      END;

  System* = POINTER TO RECORD (Object)
            STATIC
              err*                 : java_io.PrintStream;
              in*                  : java_io.InputStream;
              out*                 : java_io.PrintStream;
              PROCEDURE arraycopy*(p0 : Object;
                                   p1 : INTEGER;
                                   p2 : Object;
                                   p3 : INTEGER;
                                   p4 : INTEGER);
              PROCEDURE clearProperty*(p0 : String) : String;
              PROCEDURE console*() : java_io.Console;
              PROCEDURE currentTimeMillis*() : LONGINT;
              PROCEDURE exit*(p0 : INTEGER);
              PROCEDURE gc*();
              PROCEDURE getenv*() : java_util.Map;
              PROCEDURE getenv*(p0 : String) : String;
              PROCEDURE getProperties*() : java_util.Properties;
              PROCEDURE getProperty*(p0 : String) : String;
              PROCEDURE getProperty*(p0 : String;
                                     p1 : String) : String;
              PROCEDURE getSecurityManager*() : SecurityManager;
              PROCEDURE identityHashCode*(p0 : Object) : INTEGER;
              PROCEDURE inheritedChannel*() : java_nio_channels.Channel;
              PROCEDURE load*(p0 : String);
              PROCEDURE loadLibrary*(p0 : String);
              PROCEDURE mapLibraryName*(p0 : String) : String;
              PROCEDURE nanoTime*() : LONGINT;
              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)    (* Typebound Procedures *)
            STATIC
              MAX_PRIORITY*                       = 10;
              MIN_PRIORITY*                       = 1;
              NORM_PRIORITY*                      = 5;
              PROCEDURE activeCount*() : INTEGER;
              PROCEDURE currentThread*() : Thread;
              PROCEDURE dumpStack*();
              PROCEDURE enumerate*(IN  p0 : ARRAY OF Thread) : INTEGER;
              PROCEDURE getAllStackTraces*() : java_util.Map;
              PROCEDURE getDefaultUncaughtExceptionHandler*() : Thread$UncaughtExceptionHandler;
              PROCEDURE holdsLock*(p0 : Object) : BOOLEAN;
              PROCEDURE Init*(p0 : ThreadGroup;
                              p1 : Runnable;
                              p2 : String) : Thread,CONSTRUCTOR;
              PROCEDURE Init*(p0 : ThreadGroup;
                              p1 : Runnable;
                              p2 : String;
                              p3 : LONGINT) : Thread,CONSTRUCTOR;
              PROCEDURE Init*(p0 : Runnable;
                              p1 : String) : Thread,CONSTRUCTOR;
              PROCEDURE Init*(p0 : ThreadGroup;
                              p1 : Runnable) : Thread,CONSTRUCTOR;
              PROCEDURE Init*(p0 : Runnable) : Thread,CONSTRUCTOR;
              PROCEDURE Init*() : Thread,CONSTRUCTOR;
              PROCEDURE Init*(p0 : ThreadGroup;
                              p1 : String) : Thread,CONSTRUCTOR;
              PROCEDURE Init*(p0 : String) : Thread,CONSTRUCTOR;
              PROCEDURE interrupted*() : BOOLEAN;
              PROCEDURE setDefaultUncaughtExceptionHandler*(p0 : Thread$UncaughtExceptionHandler);
              PROCEDURE sleep*(p0 : LONGINT);
              PROCEDURE sleep*(p0 : LONGINT;
                               p1 : INTEGER);
              PROCEDURE yield*();
            END;

  Thread$State* = POINTER TO RECORD (Enum)
                  STATIC
                    BLOCKED*       : Thread$State;
                    NEW*           : Thread$State;
                    RUNNABLE*      : Thread$State;
                    TERMINATED*    : Thread$State;
                    TIMED_WAITING* : Thread$State;
                    WAITING*       : Thread$State;
                    PROCEDURE valueOf*(p0 : String) : Thread$State;
                    PROCEDURE values*() : POINTER TO ARRAY OF Thread$State;
                  END;

  Thread$UncaughtExceptionHandler* = POINTER TO INTERFACE RECORD (Object)    (* Typebound Procedures *)
                                     END;

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

  ThreadGroup* = POINTER TO EXTENSIBLE RECORD (Object + Thread$UncaughtExceptionHandler)    (* Typebound Procedures *)
                 STATIC
                   PROCEDURE Init*(p0 : ThreadGroup;
                                   p1 : String) : ThreadGroup,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : String) : ThreadGroup,CONSTRUCTOR;
                 END;

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

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

  TypeNotPresentException* = POINTER TO EXTENSIBLE RECORD (RuntimeException)    (* Typebound Procedures *)
                             STATIC
                               PROCEDURE Init*(p0 : String;
                                               p1 : Throwable) : TypeNotPresentException,CONSTRUCTOR;
                             END;

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

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

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

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

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

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

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




PROCEDURE (self:Appendable) append*(p0 : CHAR) : Appendable,NEW,ABSTRACT;

PROCEDURE (self:Appendable) append*(p0 : CharSequence;
                                    p1 : INTEGER;
                                    p2 : INTEGER) : Appendable,NEW,ABSTRACT;

PROCEDURE (self:Appendable) append*(p0 : CharSequence) : Appendable,NEW,ABSTRACT;

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

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

PROCEDURE (self:Boolean) compareTo*(p0 : Object) : INTEGER,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) 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:Character$Subset) equals*(p0 : Object) : BOOLEAN;

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

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

PROCEDURE (self:CharSequence) charAt*(p0 : INTEGER) : CHAR,NEW,ABSTRACT;

PROCEDURE (self:CharSequence) length*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:CharSequence) subSequence*(p0 : INTEGER;
                                           p1 : INTEGER) : CharSequence,NEW,ABSTRACT;

PROCEDURE (self:CharSequence) toString*() : String,ABSTRACT;

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

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

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

PROCEDURE (self:Class) getAnnotation*(p0 : Class) : java_lang_annotation.Annotation,NEW,EXTENSIBLE;

PROCEDURE (self:Class) getAnnotations*() : POINTER TO ARRAY OF java_lang_annotation.Annotation,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:Class) getClassLoader*() : ClassLoader,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) getDeclaredAnnotations*() : POINTER TO ARRAY OF java_lang_annotation.Annotation,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) getEnclosingClass*() : Class,NEW,EXTENSIBLE;

PROCEDURE (self:Class) getEnclosingConstructor*() : java_lang_reflect.Constructor,NEW,EXTENSIBLE;

PROCEDURE (self:Class) getEnclosingMethod*() : java_lang_reflect.Method,NEW,EXTENSIBLE;

PROCEDURE (self:Class) getEnumConstants*() : POINTER TO ARRAY OF Object,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) getGenericInterfaces*() : POINTER TO ARRAY OF java_lang_reflect.Type,NEW,EXTENSIBLE;

PROCEDURE (self:Class) getGenericSuperclass*() : java_lang_reflect.Type,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) getSimpleName*() : String,NEW,EXTENSIBLE;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PROCEDURE (self:ClassLoader) clearAssertionStatus*(),NEW,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!(p0 : String;
                                          p1 : java_nio.ByteBuffer;
                                          p2 : 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,EXTENSIBLE;

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

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

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

PROCEDURE (self:ClassLoader) setClassAssertionStatus*(p0 : String;
                                                      p1 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:ClassLoader) setDefaultAssertionStatus*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:ClassLoader) setPackageAssertionStatus*(p0 : String;
                                                        p1 : BOOLEAN),NEW,EXTENSIBLE;

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

PROCEDURE (self:ClassNotFoundException) getCause*() : Throwable,EXTENSIBLE;

PROCEDURE (self:ClassNotFoundException) getException*() : Throwable,NEW,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:Enum) clone!() : Object;

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

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

PROCEDURE (self:Enum) equals*(p0 : Object) : BOOLEAN;

PROCEDURE (self:Enum) finalize!();

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

PROCEDURE (self:Enum) hashCode*() : INTEGER;

PROCEDURE (self:Enum) name*() : String,NEW;

PROCEDURE (self:Enum) ordinal*() : INTEGER,NEW;

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

PROCEDURE (self:EnumConstantNotPresentException) constantName*() : String,NEW,EXTENSIBLE;

PROCEDURE (self:EnumConstantNotPresentException) enumType*() : Class,NEW,EXTENSIBLE;

PROCEDURE (self:ExceptionInInitializerError) getCause*() : Throwable,EXTENSIBLE;

PROCEDURE (self:ExceptionInInitializerError) getException*() : Throwable,NEW,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,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:Iterable) iterator*() : java_util.Iterator,NEW,ABSTRACT;

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) getAnnotation*(p0 : Class) : java_lang_annotation.Annotation,NEW,EXTENSIBLE;

PROCEDURE (self:Package) getAnnotations*() : POINTER TO ARRAY OF java_lang_annotation.Annotation,NEW,EXTENSIBLE;

PROCEDURE (self:Package) getDeclaredAnnotations*() : POINTER TO ARRAY OF java_lang_annotation.Annotation,NEW,EXTENSIBLE;

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) isAnnotationPresent*(p0 : Class) : BOOLEAN,NEW,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:ProcessBuilder) command*() : java_util.List,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) command*(IN  p0 : ARRAY OF String) : ProcessBuilder,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) command*(p0 : java_util.List) : ProcessBuilder,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) directory*(p0 : java_io.File) : ProcessBuilder,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) directory*() : java_io.File,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) environment*() : java_util.Map,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) redirectErrorStream*(p0 : BOOLEAN) : ProcessBuilder,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) redirectErrorStream*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ProcessBuilder) start*() : Process,NEW,EXTENSIBLE;

PROCEDURE (self:Readable) read*(p0 : java_nio.CharBuffer) : INTEGER,NEW,ABSTRACT;

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

PROCEDURE (self:Runtime) addShutdownHook*(p0 : Thread),NEW,EXTENSIBLE;

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

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

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

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

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

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) 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) halt*(p0 : INTEGER),NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:Runtime) removeShutdownHook*(p0 : Thread) : BOOLEAN,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 : ThreadGroup),NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:SecurityManager) checkConnect*(p0 : String;
                                               p1 : INTEGER),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;
                                                  p1 : Object),NEW,EXTENSIBLE;

PROCEDURE (self:SecurityManager) checkPermission*(p0 : java_security.Permission),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 : String),NEW,EXTENSIBLE;

PROCEDURE (self:SecurityManager) checkRead*(p0 : java_io.FileDescriptor),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 : Short) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Short) compareTo*(p0 : Object) : 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:StackTraceElement) equals*(p0 : Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:StackTraceElement) getClassName*() : String,NEW,EXTENSIBLE;

PROCEDURE (self:StackTraceElement) getFileName*() : String,NEW,EXTENSIBLE;

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

PROCEDURE (self:StackTraceElement) getMethodName*() : String,NEW,EXTENSIBLE;

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

PROCEDURE (self:StackTraceElement) isNativeMethod*() : BOOLEAN,NEW,EXTENSIBLE;

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

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

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

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

PROCEDURE (self:String) codePointCount*(p0 : INTEGER;
                                        p1 : INTEGER) : INTEGER,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) contains*(p0 : CharSequence) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:String) contentEquals*(p0 : CharSequence) : BOOLEAN,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*(    p0 : INTEGER;
                                      p1 : INTEGER;
                                  IN  p2 : ARRAY OF BYTE;
                                      p3 : INTEGER),NEW,EXTENSIBLE;

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

PROCEDURE (self:String) getBytes*(p0 : java_nio_charset.Charset) : POINTER TO ARRAY OF BYTE,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) isEmpty*() : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:String) lastIndexOf*(p0 : String) : INTEGER,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) length*() : INTEGER,NEW,EXTENSIBLE;

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

PROCEDURE (self:String) offsetByCodePoints*(p0 : INTEGER;
                                            p1 : INTEGER) : 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) replace*(p0 : CharSequence;
                                 p1 : CharSequence) : String,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:String) split*(p0 : String;
                               p1 : INTEGER) : POINTER TO ARRAY OF String,NEW,EXTENSIBLE;

PROCEDURE (self:String) split*(p0 : String) : POINTER TO ARRAY OF 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) subSequence*(p0 : INTEGER;
                                     p1 : INTEGER) : CharSequence,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 : REAL) : StringBuffer,NEW,EXTENSIBLE;

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

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

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

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

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

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

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

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

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

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

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

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

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

PROCEDURE (self:StringBuffer) append*(p0 : CharSequence) : AbstractStringBuilder,EXTENSIBLE;

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

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

PROCEDURE (self:StringBuffer) append*(p0 : CharSequence;
                                      p1 : INTEGER;
                                      p2 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

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

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

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

PROCEDURE (self:StringBuffer) append*(p0 : CharSequence) : Appendable,EXTENSIBLE;

PROCEDURE (self:StringBuffer) append*(p0 : CharSequence;
                                      p1 : INTEGER;
                                      p2 : INTEGER) : Appendable,EXTENSIBLE;

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

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

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

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

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

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

PROCEDURE (self:StringBuffer) appendCodePoint*(p0 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                      p1 : CharSequence;
                                      p2 : INTEGER;
                                      p3 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

PROCEDURE (self:StringBuffer) insert*(p0 : INTEGER;
                                      p1 : SHORTREAL) : AbstractStringBuilder,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) lastIndexOf*(p0 : String) : INTEGER,EXTENSIBLE;

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

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

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

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

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

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

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

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

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

PROCEDURE (self:StringBuffer) subSequence*(p0 : INTEGER;
                                           p1 : INTEGER) : CharSequence,EXTENSIBLE;

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

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

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

PROCEDURE (self:StringBuffer) trimToSize*(),EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : LONGINT) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : CHAR) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : SHORTREAL) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : CharSequence) : Appendable,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : CharSequence;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : Appendable,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : CHAR) : Appendable,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : BOOLEAN) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(IN  p0 : ARRAY OF CHAR) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : CharSequence) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : CharSequence;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

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

PROCEDURE (self:StringBuilder) append*(p0 : Object) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : String) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : StringBuffer) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) append*(p0 : REAL) : AbstractStringBuilder,EXTENSIBLE;

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

PROCEDURE (self:StringBuilder) append*(p0 : CharSequence;
                                       p1 : INTEGER;
                                       p2 : INTEGER) : StringBuilder,NEW,EXTENSIBLE;

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

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

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

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

PROCEDURE (self:StringBuilder) append*(p0 : CharSequence) : StringBuilder,NEW,EXTENSIBLE;

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

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

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

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

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

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

PROCEDURE (self:StringBuilder) appendCodePoint*(p0 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) appendCodePoint*(p0 : INTEGER) : StringBuilder,NEW,EXTENSIBLE;

PROCEDURE (self:StringBuilder) capacity*() : INTEGER,EXTENSIBLE;

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

PROCEDURE (self:StringBuilder) codePointAt*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringBuilder) codePointBefore*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringBuilder) codePointCount*(p0 : INTEGER;
                                               p1 : INTEGER) : INTEGER,EXTENSIBLE;

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

PROCEDURE (self:StringBuilder) delete*(p0 : INTEGER;
                                       p1 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

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

PROCEDURE (self:StringBuilder) deleteCharAt*(p0 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

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

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

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

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

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : Object) : AbstractStringBuilder,EXTENSIBLE;

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

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

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : CharSequence;
                                       p2 : INTEGER;
                                       p3 : INTEGER) : StringBuilder,NEW,EXTENSIBLE;

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : REAL) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : LONGINT) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : SHORTREAL) : AbstractStringBuilder,EXTENSIBLE;

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

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

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

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

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

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

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

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

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

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : String) : AbstractStringBuilder,EXTENSIBLE;

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

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

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : CHAR) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : BOOLEAN) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : CharSequence) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) insert*(p0 : INTEGER;
                                       p1 : CharSequence;
                                       p2 : INTEGER;
                                       p3 : INTEGER) : AbstractStringBuilder,EXTENSIBLE;

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

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

PROCEDURE (self:StringBuilder) length*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:StringBuilder) offsetByCodePoints*(p0 : INTEGER;
                                                   p1 : INTEGER) : INTEGER,EXTENSIBLE;

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

PROCEDURE (self:StringBuilder) replace*(p0 : INTEGER;
                                        p1 : INTEGER;
                                        p2 : String) : AbstractStringBuilder,EXTENSIBLE;

PROCEDURE (self:StringBuilder) reverse*() : AbstractStringBuilder,EXTENSIBLE;

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

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

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

PROCEDURE (self:StringBuilder) subSequence*(p0 : INTEGER;
                                            p1 : INTEGER) : CharSequence,EXTENSIBLE;

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

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

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

PROCEDURE (self:StringBuilder) trimToSize*(),EXTENSIBLE;

PROCEDURE (self:SuppressWarnings) value*() : POINTER TO ARRAY OF String,NEW,ABSTRACT;

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

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

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

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

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

PROCEDURE (self:Thread) getId*() : LONGINT,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:Thread) getStackTrace*() : POINTER TO ARRAY OF StackTraceElement,NEW,EXTENSIBLE;

PROCEDURE (self:Thread) getState*() : Thread$State,NEW,EXTENSIBLE;

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

PROCEDURE (self:Thread) getUncaughtExceptionHandler*() : Thread$UncaughtExceptionHandler,NEW,EXTENSIBLE;

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*(p0 : LONGINT;
                              p1 : INTEGER),NEW;

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

PROCEDURE (self:Thread) join*(p0 : LONGINT),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) setUncaughtExceptionHandler*(p0 : Thread$UncaughtExceptionHandler),NEW,EXTENSIBLE;

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

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

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

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

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

PROCEDURE (self:Thread$UncaughtExceptionHandler) uncaughtException*(p0 : Thread;
                                                                    p1 : Throwable),NEW,ABSTRACT;

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 ThreadGroup;
                                            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 Thread;
                                            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) remove*(),NEW,EXTENSIBLE;

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

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

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

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

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

PROCEDURE (self:Throwable) getStackTrace*() : POINTER TO ARRAY OF StackTraceElement,NEW,EXTENSIBLE;

PROCEDURE (self:Throwable) initCause*(p0 : Throwable) : Throwable,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:Throwable) setStackTrace*(IN  p0 : ARRAY OF StackTraceElement),NEW,EXTENSIBLE;

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

PROCEDURE (self:TypeNotPresentException) typeName*() : String,NEW,EXTENSIBLE;

END java_lang.