FOREIGN MODULE java_lang;

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

TYPE

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

END java_lang.