FOREIGN MODULE java_util;

IMPORT
    java_lang := "java.lang",
    java_io := "java.io",
    java_security := "java.security",
    sun_util_calendar := "sun.util.calendar",
    java_text := "java.text",
    sun_util := "sun.util",
    java_util_spi := "java.util.spi",
    java_math := "java.math",
    java_util_regex := "java.util.regex",
    java_util_concurrent := "java.util.concurrent",
    java_lang_ref := "java.lang.ref",
    sun_util_resources := "sun.util.resources",
    java_util_concurrent_atomic := "java.util.concurrent.atomic",
    sun_misc := "sun.misc",
    java_net := "java.net",
    java_nio := "java.nio",
    java_nio_channels := "java.nio.channels",
    sun_nio_ch := "sun.nio.ch",
    org_xml_sax := "org.xml.sax",
    org_w3c_dom := "org.w3c.dom";

TYPE

  AbstractCollection* = POINTER TO ABSTRACT RECORD (java_lang.Object + Collection)    (* Typebound Procedures *)
                        STATIC
                          PROCEDURE Init!() : AbstractCollection,CONSTRUCTOR;
                        END;

  AbstractList* = POINTER TO ABSTRACT RECORD (AbstractCollection + List)    (* Typebound Procedures *)
                    modCount! : INTEGER;
                  STATIC
                    PROCEDURE Init!() : AbstractList,CONSTRUCTOR;
                  END;

  AbstractMap* = POINTER TO ABSTRACT RECORD (java_lang.Object + Map)    (* Typebound Procedures *)
                 STATIC
                   PROCEDURE Init!() : AbstractMap,CONSTRUCTOR;
                 END;

  AbstractMap$SimpleEntry* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Map$Entry + java_io.Serializable)    (* Typebound Procedures *)
                             STATIC
                               PROCEDURE Init*(p0 : Map$Entry) : AbstractMap$SimpleEntry,CONSTRUCTOR;
                               PROCEDURE Init*(p0 : java_lang.Object;
                                               p1 : java_lang.Object) : AbstractMap$SimpleEntry,CONSTRUCTOR;
                             END;

  AbstractMap$SimpleImmutableEntry* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Map$Entry + java_io.Serializable)    (* Typebound Procedures *)
                                      STATIC
                                        PROCEDURE Init*(p0 : Map$Entry) : AbstractMap$SimpleImmutableEntry,CONSTRUCTOR;
                                        PROCEDURE Init*(p0 : java_lang.Object;
                                                        p1 : java_lang.Object) : AbstractMap$SimpleImmutableEntry,CONSTRUCTOR;
                                      END;

  AbstractQueue* = POINTER TO ABSTRACT RECORD (AbstractCollection + Queue)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init!() : AbstractQueue,CONSTRUCTOR;
                   END;

  AbstractSequentialList* = POINTER TO ABSTRACT RECORD (AbstractList)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE Init!() : AbstractSequentialList,CONSTRUCTOR;
                            END;

  AbstractSet* = POINTER TO ABSTRACT RECORD (AbstractCollection + Set)    (* Typebound Procedures *)
                 STATIC
                   PROCEDURE Init!() : AbstractSet,CONSTRUCTOR;
                 END;

  ArrayDeque* = POINTER TO EXTENSIBLE RECORD (AbstractCollection + Deque + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE Init*(p0 : Collection) : ArrayDeque,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : INTEGER) : ArrayDeque,CONSTRUCTOR;
                  PROCEDURE Init*() : ArrayDeque,CONSTRUCTOR;
                END;

  ArrayList* = POINTER TO EXTENSIBLE RECORD (AbstractList + List + RandomAccess + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
               STATIC
                 PROCEDURE Init*(p0 : Collection) : ArrayList,CONSTRUCTOR;
                 PROCEDURE Init*() : ArrayList,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : INTEGER) : ArrayList,CONSTRUCTOR;
               END;

  Arrays* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
            STATIC
              PROCEDURE asList*(IN  p0 : ARRAY OF java_lang.Object) : List;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF SHORTINT;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : SHORTINT) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF CHAR;
                                          p1 : CHAR) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF BYTE;
                                          p1 : BYTE) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF CHAR;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : CHAR) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF INTEGER;
                                          p1 : INTEGER) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF LONGINT;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : LONGINT) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF SHORTINT;
                                          p1 : SHORTINT) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF INTEGER;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : INTEGER) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF BYTE;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : BYTE) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF java_lang.Object;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : java_lang.Object) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF java_lang.Object;
                                          p1 : java_lang.Object) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF java_lang.Object;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : java_lang.Object;
                                          p4 : Comparator) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF java_lang.Object;
                                          p1 : java_lang.Object;
                                          p2 : Comparator) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF REAL;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : REAL) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF REAL;
                                          p1 : REAL) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF SHORTREAL;
                                          p1 : INTEGER;
                                          p2 : INTEGER;
                                          p3 : SHORTREAL) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF SHORTREAL;
                                          p1 : SHORTREAL) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF LONGINT;
                                          p1 : LONGINT) : INTEGER;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF SHORTINT;
                                    p1 : INTEGER) : POINTER TO ARRAY OF SHORTINT;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF INTEGER;
                                    p1 : INTEGER) : POINTER TO ARRAY OF INTEGER;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF BYTE;
                                    p1 : INTEGER) : POINTER TO ARRAY OF BYTE;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF java_lang.Object;
                                    p1 : INTEGER) : POINTER TO ARRAY OF java_lang.Object;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF java_lang.Object;
                                    p1 : INTEGER;
                                    p2 : java_lang.Class) : POINTER TO ARRAY OF java_lang.Object;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF SHORTREAL;
                                    p1 : INTEGER) : POINTER TO ARRAY OF SHORTREAL;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF CHAR;
                                    p1 : INTEGER) : POINTER TO ARRAY OF CHAR;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF REAL;
                                    p1 : INTEGER) : POINTER TO ARRAY OF REAL;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF LONGINT;
                                    p1 : INTEGER) : POINTER TO ARRAY OF LONGINT;
              PROCEDURE copyOf*(IN  p0 : ARRAY OF BOOLEAN;
                                    p1 : INTEGER) : POINTER TO ARRAY OF BOOLEAN;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF REAL;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF REAL;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF BOOLEAN;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF BOOLEAN;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF SHORTINT;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF SHORTINT;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF INTEGER;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF INTEGER;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF BYTE;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF BYTE;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF java_lang.Object;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF java_lang.Object;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF java_lang.Object;
                                         p1 : INTEGER;
                                         p2 : INTEGER;
                                         p3 : java_lang.Class) : POINTER TO ARRAY OF java_lang.Object;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF LONGINT;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF LONGINT;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF CHAR;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF CHAR;
              PROCEDURE copyOfRange*(IN  p0 : ARRAY OF SHORTREAL;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : POINTER TO ARRAY OF SHORTREAL;
              PROCEDURE deepEquals*(IN  p0 : ARRAY OF java_lang.Object;
                                    IN  p1 : ARRAY OF java_lang.Object) : BOOLEAN;
              PROCEDURE deepHashCode*(IN  p0 : ARRAY OF java_lang.Object) : INTEGER;
              PROCEDURE deepToString*(IN  p0 : ARRAY OF java_lang.Object) : java_lang.String;
              PROCEDURE equals*(IN  p0 : ARRAY OF java_lang.Object;
                                IN  p1 : ARRAY OF java_lang.Object) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF SHORTREAL;
                                IN  p1 : ARRAY OF SHORTREAL) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF SHORTINT;
                                IN  p1 : ARRAY OF SHORTINT) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF INTEGER;
                                IN  p1 : ARRAY OF INTEGER) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF LONGINT;
                                IN  p1 : ARRAY OF LONGINT) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF CHAR;
                                IN  p1 : ARRAY OF CHAR) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF REAL;
                                IN  p1 : ARRAY OF REAL) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF BOOLEAN;
                                IN  p1 : ARRAY OF BOOLEAN) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF BYTE;
                                IN  p1 : ARRAY OF BYTE) : BOOLEAN;
              PROCEDURE fill*(IN  p0 : ARRAY OF SHORTREAL;
                                  p1 : SHORTREAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF REAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : REAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF REAL;
                                  p1 : REAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF java_lang.Object;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : java_lang.Object);
              PROCEDURE fill*(IN  p0 : ARRAY OF java_lang.Object;
                                  p1 : java_lang.Object);
              PROCEDURE fill*(IN  p0 : ARRAY OF SHORTREAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : SHORTREAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF INTEGER;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : INTEGER);
              PROCEDURE fill*(IN  p0 : ARRAY OF SHORTINT;
                                  p1 : SHORTINT);
              PROCEDURE fill*(IN  p0 : ARRAY OF SHORTINT;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : SHORTINT);
              PROCEDURE fill*(IN  p0 : ARRAY OF LONGINT;
                                  p1 : LONGINT);
              PROCEDURE fill*(IN  p0 : ARRAY OF LONGINT;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : LONGINT);
              PROCEDURE fill*(IN  p0 : ARRAY OF INTEGER;
                                  p1 : INTEGER);
              PROCEDURE fill*(IN  p0 : ARRAY OF BYTE;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : BYTE);
              PROCEDURE fill*(IN  p0 : ARRAY OF BOOLEAN;
                                  p1 : BOOLEAN);
              PROCEDURE fill*(IN  p0 : ARRAY OF BOOLEAN;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : BOOLEAN);
              PROCEDURE fill*(IN  p0 : ARRAY OF CHAR;
                                  p1 : CHAR);
              PROCEDURE fill*(IN  p0 : ARRAY OF CHAR;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : CHAR);
              PROCEDURE fill*(IN  p0 : ARRAY OF BYTE;
                                  p1 : BYTE);
              PROCEDURE hashCode*(IN  p0 : ARRAY OF BOOLEAN) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF SHORTREAL) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF BYTE) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF SHORTINT) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF CHAR) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF INTEGER) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF LONGINT) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF REAL) : INTEGER;
              PROCEDURE hashCode*(IN  p0 : ARRAY OF java_lang.Object) : INTEGER;
              PROCEDURE sort*(IN  p0 : ARRAY OF INTEGER;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF LONGINT);
              PROCEDURE sort*(IN  p0 : ARRAY OF LONGINT;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF SHORTINT);
              PROCEDURE sort*(IN  p0 : ARRAY OF java_lang.Object);
              PROCEDURE sort*(IN  p0 : ARRAY OF SHORTREAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF SHORTREAL);
              PROCEDURE sort*(IN  p0 : ARRAY OF java_lang.Object;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : Comparator);
              PROCEDURE sort*(IN  p0 : ARRAY OF java_lang.Object;
                                  p1 : Comparator);
              PROCEDURE sort*(IN  p0 : ARRAY OF java_lang.Object;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF REAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF CHAR;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF CHAR);
              PROCEDURE sort*(IN  p0 : ARRAY OF SHORTINT;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF REAL);
              PROCEDURE sort*(IN  p0 : ARRAY OF BYTE;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF BYTE);
              PROCEDURE toString*(IN  p0 : ARRAY OF SHORTREAL) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF BOOLEAN) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF java_lang.Object) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF REAL) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF INTEGER) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF LONGINT) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF SHORTINT) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF BYTE) : java_lang.String;
              PROCEDURE toString*(IN  p0 : ARRAY OF CHAR) : java_lang.String;
            END;

  BitSet* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
            STATIC
              PROCEDURE Init*(p0 : INTEGER) : BitSet,CONSTRUCTOR;
              PROCEDURE Init*() : BitSet,CONSTRUCTOR;
            END;

  Calendar* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_io.Serializable + java_lang.Cloneable + java_lang.Comparable)    (* Typebound Procedures *)
                fields!       : POINTER TO ARRAY OF INTEGER;
                isSet!        : POINTER TO ARRAY OF BOOLEAN;
                time!         : LONGINT;
                isTimeSet!    : BOOLEAN;
                areFieldsSet! : BOOLEAN;
              STATIC
                ALL_STYLES*           = 0;
                AM*                   = 0;
                AM_PM*                = 9;
                APRIL*                = 3;
                AUGUST*               = 7;
                DATE*                 = 5;
                DAY_OF_MONTH*         = 5;
                DAY_OF_WEEK*          = 7;
                DAY_OF_WEEK_IN_MONTH* = 8;
                DAY_OF_YEAR*          = 6;
                DECEMBER*             = 11;
                DST_OFFSET*           = 16;
                ERA*                  = 0;
                FEBRUARY*             = 1;
                FIELD_COUNT*          = 17;
                FRIDAY*               = 6;
                HOUR*                 = 10;
                HOUR_OF_DAY*          = 11;
                JANUARY*              = 0;
                JULY*                 = 6;
                JUNE*                 = 5;
                LONG*                 = 2;
                MARCH*                = 2;
                MAY*                  = 4;
                MILLISECOND*          = 14;
                MINUTE*               = 12;
                MONDAY*               = 2;
                MONTH*                = 2;
                NOVEMBER*             = 10;
                OCTOBER*              = 9;
                PM*                   = 1;
                SATURDAY*             = 7;
                SECOND*               = 13;
                SEPTEMBER*            = 8;
                SHORT*                = 1;
                SUNDAY*               = 1;
                THURSDAY*             = 5;
                TUESDAY*              = 3;
                UNDECIMBER*           = 12;
                WEDNESDAY*            = 4;
                WEEK_OF_MONTH*        = 4;
                WEEK_OF_YEAR*         = 3;
                YEAR*                 = 1;
                ZONE_OFFSET*          = 15;
                PROCEDURE getAvailableLocales*() : POINTER TO ARRAY OF Locale;
                PROCEDURE getInstance*(p0 : Locale) : Calendar;
                PROCEDURE getInstance*(p0 : TimeZone;
                                       p1 : Locale) : Calendar;
                PROCEDURE getInstance*(p0 : TimeZone) : Calendar;
                PROCEDURE getInstance*() : Calendar;
                PROCEDURE Init!() : Calendar,CONSTRUCTOR;
                PROCEDURE Init!(p0 : TimeZone;
                                p1 : Locale) : Calendar,CONSTRUCTOR;
              END;

  Collection* = POINTER TO INTERFACE RECORD (java_lang.Object + java_lang.Iterable)    (* Typebound Procedures *)
                END;

  Collections* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                 STATIC
                   EMPTY_LIST*             : List;
                   EMPTY_MAP*              : Map;
                   EMPTY_SET*              : Set;
                   PROCEDURE addAll*(    p0 : Collection;
                                     IN  p1 : ARRAY OF java_lang.Object) : BOOLEAN;
                   PROCEDURE asLifoQueue*(p0 : Deque) : Queue;
                   PROCEDURE binarySearch*(p0 : List;
                                           p1 : java_lang.Object;
                                           p2 : Comparator) : INTEGER;
                   PROCEDURE binarySearch*(p0 : List;
                                           p1 : java_lang.Object) : INTEGER;
                   PROCEDURE checkedCollection*(p0 : Collection;
                                                p1 : java_lang.Class) : Collection;
                   PROCEDURE checkedList*(p0 : List;
                                          p1 : java_lang.Class) : List;
                   PROCEDURE checkedMap*(p0 : Map;
                                         p1 : java_lang.Class;
                                         p2 : java_lang.Class) : Map;
                   PROCEDURE checkedSet*(p0 : Set;
                                         p1 : java_lang.Class) : Set;
                   PROCEDURE checkedSortedMap*(p0 : SortedMap;
                                               p1 : java_lang.Class;
                                               p2 : java_lang.Class) : SortedMap;
                   PROCEDURE checkedSortedSet*(p0 : SortedSet;
                                               p1 : java_lang.Class) : SortedSet;
                   PROCEDURE copy*(p0 : List;
                                   p1 : List);
                   PROCEDURE disjoint*(p0 : Collection;
                                       p1 : Collection) : BOOLEAN;
                   PROCEDURE emptyList*() : List;
                   PROCEDURE emptyMap*() : Map;
                   PROCEDURE emptySet*() : Set;
                   PROCEDURE enumeration*(p0 : Collection) : Enumeration;
                   PROCEDURE fill*(p0 : List;
                                   p1 : java_lang.Object);
                   PROCEDURE frequency*(p0 : Collection;
                                        p1 : java_lang.Object) : INTEGER;
                   PROCEDURE indexOfSubList*(p0 : List;
                                             p1 : List) : INTEGER;
                   PROCEDURE lastIndexOfSubList*(p0 : List;
                                                 p1 : List) : INTEGER;
                   PROCEDURE list*(p0 : Enumeration) : ArrayList;
                   PROCEDURE max*(p0 : Collection) : java_lang.Object;
                   PROCEDURE max*(p0 : Collection;
                                  p1 : Comparator) : java_lang.Object;
                   PROCEDURE min*(p0 : Collection;
                                  p1 : Comparator) : java_lang.Object;
                   PROCEDURE min*(p0 : Collection) : java_lang.Object;
                   PROCEDURE nCopies*(p0 : INTEGER;
                                      p1 : java_lang.Object) : List;
                   PROCEDURE newSetFromMap*(p0 : Map) : Set;
                   PROCEDURE replaceAll*(p0 : List;
                                         p1 : java_lang.Object;
                                         p2 : java_lang.Object) : BOOLEAN;
                   PROCEDURE reverse*(p0 : List);
                   PROCEDURE reverseOrder*() : Comparator;
                   PROCEDURE reverseOrder*(p0 : Comparator) : Comparator;
                   PROCEDURE rotate*(p0 : List;
                                     p1 : INTEGER);
                   PROCEDURE shuffle*(p0 : List);
                   PROCEDURE shuffle*(p0 : List;
                                      p1 : Random);
                   PROCEDURE singleton*(p0 : java_lang.Object) : Set;
                   PROCEDURE singletonList*(p0 : java_lang.Object) : List;
                   PROCEDURE singletonMap*(p0 : java_lang.Object;
                                           p1 : java_lang.Object) : Map;
                   PROCEDURE sort*(p0 : List;
                                   p1 : Comparator);
                   PROCEDURE sort*(p0 : List);
                   PROCEDURE swap*(p0 : List;
                                   p1 : INTEGER;
                                   p2 : INTEGER);
                   PROCEDURE synchronizedCollection*(p0 : Collection) : Collection;
                   PROCEDURE synchronizedList*(p0 : List) : List;
                   PROCEDURE synchronizedMap*(p0 : Map) : Map;
                   PROCEDURE synchronizedSet*(p0 : Set) : Set;
                   PROCEDURE synchronizedSortedMap*(p0 : SortedMap) : SortedMap;
                   PROCEDURE synchronizedSortedSet*(p0 : SortedSet) : SortedSet;
                   PROCEDURE unmodifiableCollection*(p0 : Collection) : Collection;
                   PROCEDURE unmodifiableList*(p0 : List) : List;
                   PROCEDURE unmodifiableMap*(p0 : Map) : Map;
                   PROCEDURE unmodifiableSet*(p0 : Set) : Set;
                   PROCEDURE unmodifiableSortedMap*(p0 : SortedMap) : SortedMap;
                   PROCEDURE unmodifiableSortedSet*(p0 : SortedSet) : SortedSet;
                 END;

  Comparator* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                END;

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

  Currency* = POINTER TO RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
              STATIC
                PROCEDURE getInstance*(p0 : Locale) : Currency;
                PROCEDURE getInstance*(p0 : java_lang.String) : Currency;
              END;

  Date* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable + java_lang.Cloneable + java_lang.Comparable)    (* Typebound Procedures *)
          STATIC
            PROCEDURE Init*(p0 : INTEGER;
                            p1 : INTEGER;
                            p2 : INTEGER;
                            p3 : INTEGER;
                            p4 : INTEGER) : Date,CONSTRUCTOR;
            PROCEDURE Init*(p0 : INTEGER;
                            p1 : INTEGER;
                            p2 : INTEGER;
                            p3 : INTEGER;
                            p4 : INTEGER;
                            p5 : INTEGER) : Date,CONSTRUCTOR;
            PROCEDURE Init*(p0 : java_lang.String) : Date,CONSTRUCTOR;
            PROCEDURE Init*() : Date,CONSTRUCTOR;
            PROCEDURE Init*(p0 : LONGINT) : Date,CONSTRUCTOR;
            PROCEDURE Init*(p0 : INTEGER;
                            p1 : INTEGER;
                            p2 : INTEGER) : Date,CONSTRUCTOR;
            PROCEDURE parse*(p0 : java_lang.String) : LONGINT;
            PROCEDURE UTC*(p0 : INTEGER;
                           p1 : INTEGER;
                           p2 : INTEGER;
                           p3 : INTEGER;
                           p4 : INTEGER;
                           p5 : INTEGER) : LONGINT;
          END;

  Deque* = POINTER TO INTERFACE RECORD (java_lang.Object + Queue)    (* Typebound Procedures *)
           END;

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

  DuplicateFormatFlagsException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                   STATIC
                                     PROCEDURE Init*(p0 : java_lang.String) : DuplicateFormatFlagsException,CONSTRUCTOR;
                                   END;

  EmptyStackException* = POINTER TO EXTENSIBLE RECORD (java_lang.RuntimeException)
                         STATIC
                           PROCEDURE Init*() : EmptyStackException,CONSTRUCTOR;
                         END;

  Enumeration* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                 END;

  EnumMap* = POINTER TO EXTENSIBLE RECORD (AbstractMap + java_io.Serializable + java_lang.Cloneable)    (* Typebound Procedures *)
             STATIC
               PROCEDURE Init*(p0 : Map) : EnumMap,CONSTRUCTOR;
               PROCEDURE Init*(p0 : EnumMap) : EnumMap,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_lang.Class) : EnumMap,CONSTRUCTOR;
             END;

  EnumSet* = POINTER TO ABSTRACT RECORD (AbstractSet + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
             STATIC
               PROCEDURE allOf*(p0 : java_lang.Class) : EnumSet;
               PROCEDURE complementOf*(p0 : EnumSet) : EnumSet;
               PROCEDURE copyOf*(p0 : Collection) : EnumSet;
               PROCEDURE copyOf*(p0 : EnumSet) : EnumSet;
               PROCEDURE noneOf*(p0 : java_lang.Class) : EnumSet;
               PROCEDURE of*(p0 : java_lang.Enum;
                             p1 : java_lang.Enum;
                             p2 : java_lang.Enum;
                             p3 : java_lang.Enum) : EnumSet;
               PROCEDURE of*(p0 : java_lang.Enum;
                             p1 : java_lang.Enum;
                             p2 : java_lang.Enum;
                             p3 : java_lang.Enum;
                             p4 : java_lang.Enum) : EnumSet;
               PROCEDURE of*(    p0 : java_lang.Enum;
                             IN  p1 : ARRAY OF java_lang.Enum) : EnumSet;
               PROCEDURE of*(p0 : java_lang.Enum) : EnumSet;
               PROCEDURE of*(p0 : java_lang.Enum;
                             p1 : java_lang.Enum) : EnumSet;
               PROCEDURE of*(p0 : java_lang.Enum;
                             p1 : java_lang.Enum;
                             p2 : java_lang.Enum) : EnumSet;
               PROCEDURE range*(p0 : java_lang.Enum;
                                p1 : java_lang.Enum) : EnumSet;
             END;

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

  EventListenerProxy* = POINTER TO ABSTRACT RECORD (java_lang.Object + EventListener)    (* Typebound Procedures *)
                        STATIC
                          PROCEDURE Init*(p0 : EventListener) : EventListenerProxy,CONSTRUCTOR;
                        END;

  EventObject* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable)    (* Typebound Procedures *)
                   source! : java_lang.Object;
                 STATIC
                   PROCEDURE Init*(p0 : java_lang.Object) : EventObject,CONSTRUCTOR;
                 END;

  FormatFlagsConversionMismatchException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                            STATIC
                                              PROCEDURE Init*(p0 : java_lang.String;
                                                              p1 : CHAR) : FormatFlagsConversionMismatchException,CONSTRUCTOR;
                                            END;

  Formattable* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
                 END;

  FormattableFlags* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                      STATIC
                        ALTERNATE*    = 4;
                        LEFT_JUSTIFY* = 1;
                        UPPERCASE*    = 2;
                      END;

  Formatter* = POINTER TO RECORD (java_lang.Object + java_io.Closeable + java_io.Flushable)    (* Typebound Procedures *)
               STATIC
                 PROCEDURE Init*(p0 : java_io.File;
                                 p1 : java_lang.String;
                                 p2 : Locale) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_io.File;
                                 p1 : java_lang.String) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_io.File) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_io.PrintStream) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_io.OutputStream;
                                 p1 : java_lang.String;
                                 p2 : Locale) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_io.OutputStream;
                                 p1 : java_lang.String) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_io.OutputStream) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : Locale) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_lang.Appendable) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*() : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_lang.Appendable;
                                 p1 : Locale) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_lang.String;
                                 p1 : java_lang.String;
                                 p2 : Locale) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_lang.String;
                                 p1 : java_lang.String) : Formatter,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : java_lang.String) : Formatter,CONSTRUCTOR;
               END;

  Formatter$BigDecimalLayoutForm* = POINTER TO RECORD (java_lang.Enum)
                                    STATIC
                                      DECIMAL_FLOAT* : Formatter$BigDecimalLayoutForm;
                                      SCIENTIFIC*    : Formatter$BigDecimalLayoutForm;
                                      PROCEDURE valueOf*(p0 : java_lang.String) : Formatter$BigDecimalLayoutForm;
                                      PROCEDURE values*() : POINTER TO ARRAY OF Formatter$BigDecimalLayoutForm;
                                    END;

  FormatterClosedException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalStateException)
                              STATIC
                                PROCEDURE Init*() : FormatterClosedException,CONSTRUCTOR;
                              END;

  GregorianCalendar* = POINTER TO EXTENSIBLE RECORD (Calendar)    (* Typebound Procedures *)
                       STATIC
                         AD*   = 1;
                         BC*   = 0;
                         PROCEDURE Init*(p0 : INTEGER;
                                         p1 : INTEGER;
                                         p2 : INTEGER) : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : INTEGER;
                                         p1 : INTEGER;
                                         p2 : INTEGER;
                                         p3 : INTEGER;
                                         p4 : INTEGER) : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : INTEGER;
                                         p1 : INTEGER;
                                         p2 : INTEGER;
                                         p3 : INTEGER;
                                         p4 : INTEGER;
                                         p5 : INTEGER) : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TimeZone;
                                         p1 : Locale) : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*() : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TimeZone) : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : Locale) : GregorianCalendar,CONSTRUCTOR;
                       END;

  HashMap* = POINTER TO EXTENSIBLE RECORD (AbstractMap + Map + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
             STATIC
               PROCEDURE Init*() : HashMap,CONSTRUCTOR;
               PROCEDURE Init*(p0 : Map) : HashMap,CONSTRUCTOR;
               PROCEDURE Init*(p0 : INTEGER;
                               p1 : SHORTREAL) : HashMap,CONSTRUCTOR;
               PROCEDURE Init*(p0 : INTEGER) : HashMap,CONSTRUCTOR;
             END;

  HashSet* = POINTER TO EXTENSIBLE RECORD (AbstractSet + Set + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
             STATIC
               PROCEDURE Init*(p0 : INTEGER;
                               p1 : SHORTREAL) : HashSet,CONSTRUCTOR;
               PROCEDURE Init*(p0 : INTEGER) : HashSet,CONSTRUCTOR;
               PROCEDURE Init*() : HashSet,CONSTRUCTOR;
               PROCEDURE Init*(p0 : Collection) : HashSet,CONSTRUCTOR;
             END;

  Hashtable* = POINTER TO EXTENSIBLE RECORD (Dictionary + Map + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
               STATIC
                 PROCEDURE Init*() : Hashtable,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : Map) : Hashtable,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : INTEGER;
                                 p1 : SHORTREAL) : Hashtable,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : INTEGER) : Hashtable,CONSTRUCTOR;
               END;

  IdentityHashMap* = POINTER TO EXTENSIBLE RECORD (AbstractMap + Map + java_io.Serializable + java_lang.Cloneable)    (* Typebound Procedures *)
                     STATIC
                       PROCEDURE Init*(p0 : Map) : IdentityHashMap,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : INTEGER) : IdentityHashMap,CONSTRUCTOR;
                       PROCEDURE Init*() : IdentityHashMap,CONSTRUCTOR;
                     END;

  IllegalFormatCodePointException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                     STATIC
                                       PROCEDURE Init*(p0 : INTEGER) : IllegalFormatCodePointException,CONSTRUCTOR;
                                     END;

  IllegalFormatConversionException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                      STATIC
                                        PROCEDURE Init*(p0 : CHAR;
                                                        p1 : java_lang.Class) : IllegalFormatConversionException,CONSTRUCTOR;
                                      END;

  IllegalFormatException* = POINTER TO EXTENSIBLE RECORD (java_lang.IllegalArgumentException)
                            END;

  IllegalFormatFlagsException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                 STATIC
                                   PROCEDURE Init*(p0 : java_lang.String) : IllegalFormatFlagsException,CONSTRUCTOR;
                                 END;

  IllegalFormatPrecisionException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                     STATIC
                                       PROCEDURE Init*(p0 : INTEGER) : IllegalFormatPrecisionException,CONSTRUCTOR;
                                     END;

  IllegalFormatWidthException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                 STATIC
                                   PROCEDURE Init*(p0 : INTEGER) : IllegalFormatWidthException,CONSTRUCTOR;
                                 END;

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

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

  Iterator* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
              END;

  LinkedHashMap* = POINTER TO EXTENSIBLE RECORD (HashMap + Map)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*(p0 : Map) : LinkedHashMap,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER;
                                     p1 : SHORTREAL;
                                     p2 : BOOLEAN) : LinkedHashMap,CONSTRUCTOR;
                     PROCEDURE Init*() : LinkedHashMap,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER;
                                     p1 : SHORTREAL) : LinkedHashMap,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER) : LinkedHashMap,CONSTRUCTOR;
                   END;

  LinkedHashSet* = POINTER TO EXTENSIBLE RECORD (HashSet + Set + java_lang.Cloneable + java_io.Serializable)
                   STATIC
                     PROCEDURE Init*() : LinkedHashSet,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : Collection) : LinkedHashSet,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER;
                                     p1 : SHORTREAL) : LinkedHashSet,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER) : LinkedHashSet,CONSTRUCTOR;
                   END;

  LinkedList* = POINTER TO EXTENSIBLE RECORD (AbstractSequentialList + List + Deque + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE Init*(p0 : Collection) : LinkedList,CONSTRUCTOR;
                  PROCEDURE Init*() : LinkedList,CONSTRUCTOR;
                END;

  List* = POINTER TO INTERFACE RECORD (java_lang.Object + Collection)    (* Typebound Procedures *)
          END;

  ListIterator* = POINTER TO INTERFACE RECORD (java_lang.Object + Iterator)    (* Typebound Procedures *)
                  END;

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

  Locale* = POINTER TO RECORD (java_lang.Object + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
            STATIC
              CANADA*              : Locale;
              CANADA_FRENCH*       : Locale;
              CHINA*               : Locale;
              CHINESE*             : Locale;
              ENGLISH*             : Locale;
              FRANCE*              : Locale;
              FRENCH*              : Locale;
              GERMAN*              : Locale;
              GERMANY*             : Locale;
              ITALIAN*             : Locale;
              ITALY*               : Locale;
              JAPAN*               : Locale;
              JAPANESE*            : Locale;
              KOREA*               : Locale;
              KOREAN*              : Locale;
              PRC*                 : Locale;
              ROOT*                : Locale;
              SIMPLIFIED_CHINESE*  : Locale;
              TAIWAN*              : Locale;
              TRADITIONAL_CHINESE* : Locale;
              UK*                  : Locale;
              US*                  : Locale;
              PROCEDURE getAvailableLocales*() : POINTER TO ARRAY OF Locale;
              PROCEDURE getDefault*() : Locale;
              PROCEDURE getISOCountries*() : POINTER TO ARRAY OF java_lang.String;
              PROCEDURE getISOLanguages*() : POINTER TO ARRAY OF java_lang.String;
              PROCEDURE Init*(p0 : java_lang.String) : Locale,CONSTRUCTOR;
              PROCEDURE Init*(p0 : java_lang.String;
                              p1 : java_lang.String;
                              p2 : java_lang.String) : Locale,CONSTRUCTOR;
              PROCEDURE Init*(p0 : java_lang.String;
                              p1 : java_lang.String) : Locale,CONSTRUCTOR;
              PROCEDURE setDefault*(p0 : Locale);
            END;

  Map* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
         END;

  Map$Entry* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
               END;

  MissingFormatArgumentException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                    STATIC
                                      PROCEDURE Init*(p0 : java_lang.String) : MissingFormatArgumentException,CONSTRUCTOR;
                                    END;

  MissingFormatWidthException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                 STATIC
                                   PROCEDURE Init*(p0 : java_lang.String) : MissingFormatWidthException,CONSTRUCTOR;
                                 END;

  MissingResourceException* = POINTER TO EXTENSIBLE RECORD (java_lang.RuntimeException)    (* Typebound Procedures *)
                              STATIC
                                PROCEDURE Init*(p0 : java_lang.String;
                                                p1 : java_lang.String;
                                                p2 : java_lang.String) : MissingResourceException,CONSTRUCTOR;
                              END;

  NavigableMap* = POINTER TO INTERFACE RECORD (java_lang.Object + SortedMap)    (* Typebound Procedures *)
                  END;

  NavigableSet* = POINTER TO INTERFACE RECORD (java_lang.Object + SortedSet)    (* Typebound Procedures *)
                  END;

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

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

  Observer* = POINTER TO INTERFACE RECORD (java_lang.Object)    (* Typebound Procedures *)
              END;

  PriorityQueue* = POINTER TO EXTENSIBLE RECORD (AbstractQueue + java_io.Serializable)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*(p0 : Collection) : PriorityQueue,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : PriorityQueue) : PriorityQueue,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : SortedSet) : PriorityQueue,CONSTRUCTOR;
                     PROCEDURE Init*() : PriorityQueue,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER) : PriorityQueue,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER;
                                     p1 : Comparator) : PriorityQueue,CONSTRUCTOR;
                   END;

  Properties* = POINTER TO EXTENSIBLE RECORD (Hashtable)    (* Typebound Procedures *)
                  defaults! : Properties;
                STATIC
                  PROCEDURE Init*(p0 : Properties) : Properties,CONSTRUCTOR;
                  PROCEDURE Init*() : Properties,CONSTRUCTOR;
                END;

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

  PropertyResourceBundle* = POINTER TO EXTENSIBLE RECORD (ResourceBundle)    (* Typebound Procedures *)
                            STATIC
                              PROCEDURE Init*(p0 : java_io.Reader) : PropertyResourceBundle,CONSTRUCTOR;
                              PROCEDURE Init*(p0 : java_io.InputStream) : PropertyResourceBundle,CONSTRUCTOR;
                            END;

  Queue* = POINTER TO INTERFACE RECORD (java_lang.Object + Collection)    (* Typebound Procedures *)
           END;

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

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

  ResourceBundle* = POINTER TO ABSTRACT RECORD (java_lang.Object)    (* Typebound Procedures *)
                      parent! : ResourceBundle;
                    STATIC
                      PROCEDURE clearCache*();
                      PROCEDURE clearCache*(p0 : java_lang.ClassLoader);
                      PROCEDURE getBundle*(p0 : java_lang.String;
                                           p1 : Locale;
                                           p2 : java_lang.ClassLoader) : ResourceBundle;
                      PROCEDURE getBundle*(p0 : java_lang.String;
                                           p1 : Locale;
                                           p2 : java_lang.ClassLoader;
                                           p3 : ResourceBundle$Control) : ResourceBundle;
                      PROCEDURE getBundle*(p0 : java_lang.String;
                                           p1 : Locale;
                                           p2 : ResourceBundle$Control) : ResourceBundle;
                      PROCEDURE getBundle*(p0 : java_lang.String) : ResourceBundle;
                      PROCEDURE getBundle*(p0 : java_lang.String;
                                           p1 : ResourceBundle$Control) : ResourceBundle;
                      PROCEDURE getBundle*(p0 : java_lang.String;
                                           p1 : Locale) : ResourceBundle;
                      PROCEDURE Init*() : ResourceBundle,CONSTRUCTOR;
                    END;

  ResourceBundle$Control* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                            STATIC
                              FORMAT_CLASS*              : List;
                              FORMAT_DEFAULT*            : List;
                              FORMAT_PROPERTIES*         : List;
                              TTL_DONT_CACHE*            = -1;
                              TTL_NO_EXPIRATION_CONTROL* = -2;
                              PROCEDURE getControl*(p0 : List) : ResourceBundle$Control;
                              PROCEDURE getNoFallbackControl*(p0 : List) : ResourceBundle$Control;
                              PROCEDURE Init!() : ResourceBundle$Control,CONSTRUCTOR;
                            END;

  Scanner* = POINTER TO RECORD (java_lang.Object + Iterator)    (* Typebound Procedures *)
             STATIC
               PROCEDURE Init*(p0 : java_lang.String) : Scanner,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_io.File;
                               p1 : java_lang.String) : Scanner,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_nio_channels.ReadableByteChannel;
                               p1 : java_lang.String) : Scanner,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_nio_channels.ReadableByteChannel) : Scanner,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_io.InputStream) : Scanner,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_lang.Readable) : Scanner,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_io.File) : Scanner,CONSTRUCTOR;
               PROCEDURE Init*(p0 : java_io.InputStream;
                               p1 : java_lang.String) : Scanner,CONSTRUCTOR;
             END;

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

  ServiceLoader* = POINTER TO RECORD (java_lang.Object + java_lang.Iterable)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE load*(p0 : java_lang.Class) : ServiceLoader;
                     PROCEDURE load*(p0 : java_lang.Class;
                                     p1 : java_lang.ClassLoader) : ServiceLoader;
                     PROCEDURE loadInstalled*(p0 : java_lang.Class) : ServiceLoader;
                   END;

  Set* = POINTER TO INTERFACE RECORD (java_lang.Object + Collection)    (* Typebound Procedures *)
         END;

  SimpleTimeZone* = POINTER TO EXTENSIBLE RECORD (TimeZone)    (* Typebound Procedures *)
                    STATIC
                      STANDARD_TIME* = 1;
                      UTC_TIME*      = 2;
                      WALL_TIME*     = 0;
                      PROCEDURE Init*(p0  : INTEGER;
                                      p1  : java_lang.String;
                                      p2  : INTEGER;
                                      p3  : INTEGER;
                                      p4  : INTEGER;
                                      p5  : INTEGER;
                                      p6  : INTEGER;
                                      p7  : INTEGER;
                                      p8  : INTEGER;
                                      p9  : INTEGER;
                                      p10 : INTEGER) : SimpleTimeZone,CONSTRUCTOR;
                      PROCEDURE Init*(p0  : INTEGER;
                                      p1  : java_lang.String;
                                      p2  : INTEGER;
                                      p3  : INTEGER;
                                      p4  : INTEGER;
                                      p5  : INTEGER;
                                      p6  : INTEGER;
                                      p7  : INTEGER;
                                      p8  : INTEGER;
                                      p9  : INTEGER;
                                      p10 : INTEGER;
                                      p11 : INTEGER;
                                      p12 : INTEGER) : SimpleTimeZone,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : INTEGER;
                                      p1 : java_lang.String) : SimpleTimeZone,CONSTRUCTOR;
                      PROCEDURE Init*(p0 : INTEGER;
                                      p1 : java_lang.String;
                                      p2 : INTEGER;
                                      p3 : INTEGER;
                                      p4 : INTEGER;
                                      p5 : INTEGER;
                                      p6 : INTEGER;
                                      p7 : INTEGER;
                                      p8 : INTEGER;
                                      p9 : INTEGER) : SimpleTimeZone,CONSTRUCTOR;
                    END;

  SortedMap* = POINTER TO INTERFACE RECORD (java_lang.Object + Map)    (* Typebound Procedures *)
               END;

  SortedSet* = POINTER TO INTERFACE RECORD (java_lang.Object + Set)    (* Typebound Procedures *)
               END;

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

  StringTokenizer* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Enumeration)    (* Typebound Procedures *)
                     STATIC
                       PROCEDURE Init*(p0 : java_lang.String) : StringTokenizer,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : java_lang.String;
                                       p1 : java_lang.String) : StringTokenizer,CONSTRUCTOR;
                       PROCEDURE Init*(p0 : java_lang.String;
                                       p1 : java_lang.String;
                                       p2 : BOOLEAN) : StringTokenizer,CONSTRUCTOR;
                     END;

  Timer* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
           STATIC
             PROCEDURE Init*(p0 : java_lang.String) : Timer,CONSTRUCTOR;
             PROCEDURE Init*(p0 : java_lang.String;
                             p1 : BOOLEAN) : Timer,CONSTRUCTOR;
             PROCEDURE Init*() : Timer,CONSTRUCTOR;
             PROCEDURE Init*(p0 : BOOLEAN) : Timer,CONSTRUCTOR;
           END;

  TimerTask* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_lang.Runnable)    (* Typebound Procedures *)
               STATIC
                 PROCEDURE Init!() : TimerTask,CONSTRUCTOR;
               END;

  TimeZone* = POINTER TO ABSTRACT RECORD (java_lang.Object + java_io.Serializable + java_lang.Cloneable)    (* Typebound Procedures *)
              STATIC
                LONG*            = 1;
                SHORT*           = 0;
                PROCEDURE getAvailableIDs*(p0 : INTEGER) : POINTER TO ARRAY OF java_lang.String;
                PROCEDURE getAvailableIDs*() : POINTER TO ARRAY OF java_lang.String;
                PROCEDURE getDefault*() : TimeZone;
                PROCEDURE getTimeZone*(p0 : java_lang.String) : TimeZone;
                PROCEDURE Init*() : TimeZone,CONSTRUCTOR;
                PROCEDURE setDefault*(p0 : TimeZone);
              END;

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

  TreeMap* = POINTER TO EXTENSIBLE RECORD (AbstractMap + NavigableMap + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
             STATIC
               PROCEDURE Init*(p0 : Map) : TreeMap,CONSTRUCTOR;
               PROCEDURE Init*(p0 : SortedMap) : TreeMap,CONSTRUCTOR;
               PROCEDURE Init*() : TreeMap,CONSTRUCTOR;
               PROCEDURE Init*(p0 : Comparator) : TreeMap,CONSTRUCTOR;
             END;

  TreeSet* = POINTER TO EXTENSIBLE RECORD (AbstractSet + NavigableSet + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
             STATIC
               PROCEDURE Init*(p0 : Collection) : TreeSet,CONSTRUCTOR;
               PROCEDURE Init*(p0 : SortedSet) : TreeSet,CONSTRUCTOR;
               PROCEDURE Init*() : TreeSet,CONSTRUCTOR;
               PROCEDURE Init*(p0 : Comparator) : TreeSet,CONSTRUCTOR;
             END;

  UnknownFormatConversionException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                      STATIC
                                        PROCEDURE Init*(p0 : java_lang.String) : UnknownFormatConversionException,CONSTRUCTOR;
                                      END;

  UnknownFormatFlagsException* = POINTER TO EXTENSIBLE RECORD (IllegalFormatException)    (* Typebound Procedures *)
                                 STATIC
                                   PROCEDURE Init*(p0 : java_lang.String) : UnknownFormatFlagsException,CONSTRUCTOR;
                                 END;

  UUID* = POINTER TO RECORD (java_lang.Object + java_io.Serializable + java_lang.Comparable)    (* Typebound Procedures *)
          STATIC
            PROCEDURE fromString*(p0 : java_lang.String) : UUID;
            PROCEDURE Init*(p0 : LONGINT;
                            p1 : LONGINT) : UUID,CONSTRUCTOR;
            PROCEDURE nameUUIDFromBytes*(IN  p0 : ARRAY OF BYTE) : UUID;
            PROCEDURE randomUUID*() : UUID;
          END;

  Vector* = POINTER TO EXTENSIBLE RECORD (AbstractList + List + RandomAccess + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
              elementData!       : POINTER TO ARRAY OF java_lang.Object;
              elementCount!      : INTEGER;
              capacityIncrement! : INTEGER;
            STATIC
              PROCEDURE Init*() : Vector,CONSTRUCTOR;
              PROCEDURE Init*(p0 : Collection) : Vector,CONSTRUCTOR;
              PROCEDURE Init*(p0 : INTEGER;
                              p1 : INTEGER) : Vector,CONSTRUCTOR;
              PROCEDURE Init*(p0 : INTEGER) : Vector,CONSTRUCTOR;
            END;

  WeakHashMap* = POINTER TO EXTENSIBLE RECORD (AbstractMap + Map)    (* Typebound Procedures *)
                 STATIC
                   PROCEDURE Init*() : WeakHashMap,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : Map) : WeakHashMap,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER;
                                   p1 : SHORTREAL) : WeakHashMap,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER) : WeakHashMap,CONSTRUCTOR;
                 END;




PROCEDURE (self:AbstractCollection) add*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) addAll*(p0 : Collection) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) clear*(),NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) contains*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) containsAll*(p0 : Collection) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) isEmpty*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) iterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:AbstractCollection) remove*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) removeAll*(p0 : Collection) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) retainAll*(p0 : Collection) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) size*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:AbstractCollection) toArray*() : POINTER TO ARRAY OF java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractCollection) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:AbstractList) add*(p0 : INTEGER;
                                   p1 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AbstractList) addAll*(p0 : INTEGER;
                                      p1 : Collection) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) clear*(),EXTENSIBLE;

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

PROCEDURE (self:AbstractList) get*(p0 : INTEGER) : java_lang.Object,NEW,ABSTRACT;

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

PROCEDURE (self:AbstractList) indexOf*(p0 : java_lang.Object) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) iterator*() : Iterator,EXTENSIBLE;

PROCEDURE (self:AbstractList) lastIndexOf*(p0 : java_lang.Object) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) listIterator*(p0 : INTEGER) : ListIterator,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) listIterator*() : ListIterator,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) remove*(p0 : INTEGER) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) removeRange!(p0 : INTEGER;
                                           p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) set*(p0 : INTEGER;
                                   p1 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) subList*(p0 : INTEGER;
                                       p1 : INTEGER) : List,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) clear*(),NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) clone!() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:AbstractMap) containsKey*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) containsValue*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) entrySet*() : Set,NEW,ABSTRACT;

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

PROCEDURE (self:AbstractMap) get*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:AbstractMap) isEmpty*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) keySet*() : Set,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) put*(p0 : java_lang.Object;
                                  p1 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) putAll*(p0 : Map),NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap) remove*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:AbstractMap) values*() : Collection,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleEntry) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleEntry) getKey*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleEntry) getValue*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleEntry) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleEntry) setValue*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleEntry) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleImmutableEntry) equals*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleImmutableEntry) getKey*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleImmutableEntry) getValue*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleImmutableEntry) hashCode*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleImmutableEntry) setValue*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractMap$SimpleImmutableEntry) toString*() : java_lang.String,EXTENSIBLE;

PROCEDURE (self:AbstractQueue) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AbstractQueue) addAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AbstractQueue) clear*(),EXTENSIBLE;

PROCEDURE (self:AbstractQueue) element*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractQueue) remove*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractSequentialList) add*(p0 : INTEGER;
                                             p1 : java_lang.Object),EXTENSIBLE;

PROCEDURE (self:AbstractSequentialList) addAll*(p0 : INTEGER;
                                                p1 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:AbstractSequentialList) get*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:AbstractSequentialList) iterator*() : Iterator,EXTENSIBLE;

PROCEDURE (self:AbstractSequentialList) listIterator*(p0 : INTEGER) : ListIterator,ABSTRACT;

PROCEDURE (self:AbstractSequentialList) remove*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:AbstractSequentialList) set*(p0 : INTEGER;
                                             p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

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

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

PROCEDURE (self:AbstractSet) removeAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) addFirst*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) addLast*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) clear*(),EXTENSIBLE;

PROCEDURE (self:ArrayDeque) clone*() : ArrayDeque,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) contains*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) descendingIterator*() : Iterator,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) element*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) getFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) getLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) iterator*() : Iterator,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) offer*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) offerFirst*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) offerLast*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) peek*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) peekFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) peekLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) poll*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) pollFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) pollLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) pop*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) push*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) remove*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) removeFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) removeFirstOccurrence*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) removeLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) removeLastOccurrence*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) toArray*() : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayDeque) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayList) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayList) add*(p0 : INTEGER;
                                p1 : java_lang.Object),EXTENSIBLE;

PROCEDURE (self:ArrayList) addAll*(p0 : INTEGER;
                                   p1 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayList) addAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayList) clear*(),EXTENSIBLE;

PROCEDURE (self:ArrayList) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayList) contains*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

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

PROCEDURE (self:ArrayList) get*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayList) indexOf*(p0 : java_lang.Object) : INTEGER,EXTENSIBLE;

PROCEDURE (self:ArrayList) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayList) lastIndexOf*(p0 : java_lang.Object) : INTEGER,EXTENSIBLE;

PROCEDURE (self:ArrayList) remove*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayList) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ArrayList) removeRange!(p0 : INTEGER;
                                        p1 : INTEGER),EXTENSIBLE;

PROCEDURE (self:ArrayList) set*(p0 : INTEGER;
                                p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayList) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:ArrayList) toArray*() : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayList) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:ArrayList) trimToSize*(),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) and*(p0 : BitSet),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) andNot*(p0 : BitSet),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) cardinality*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) clear*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) clear*(),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) clear*(p0 : INTEGER;
                               p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) clone*() : java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:BitSet) flip*(p0 : INTEGER;
                              p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) flip*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) get*(p0 : INTEGER;
                             p1 : INTEGER) : BitSet,NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) get*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:BitSet) intersects*(p0 : BitSet) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) isEmpty*() : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:BitSet) nextClearBit*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) nextSetBit*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) or*(p0 : BitSet),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) set*(p0 : INTEGER;
                             p1 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) set*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) set*(p0 : INTEGER;
                             p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:BitSet) set*(p0 : INTEGER;
                             p1 : INTEGER;
                             p2 : BOOLEAN),NEW,EXTENSIBLE;

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

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

PROCEDURE (self:BitSet) xor*(p0 : BitSet),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) add*(p0 : INTEGER;
                               p1 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:Calendar) after*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) before*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) clear*(p0 : INTEGER),NEW;

PROCEDURE (self:Calendar) clear*(),NEW;

PROCEDURE (self:Calendar) clone*() : java_lang.Object,EXTENSIBLE;

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

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

PROCEDURE (self:Calendar) complete!(),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) computeFields!(),NEW,ABSTRACT;

PROCEDURE (self:Calendar) computeTime!(),NEW,ABSTRACT;

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

PROCEDURE (self:Calendar) get*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getActualMaximum*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getActualMinimum*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getDisplayName*(p0 : INTEGER;
                                          p1 : INTEGER;
                                          p2 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getDisplayNames*(p0 : INTEGER;
                                           p1 : INTEGER;
                                           p2 : Locale) : Map,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getFirstDayOfWeek*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getGreatestMinimum*(p0 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Calendar) getLeastMaximum*(p0 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Calendar) getMaximum*(p0 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Calendar) getMinimalDaysInFirstWeek*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getMinimum*(p0 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Calendar) getTime*() : Date,NEW;

PROCEDURE (self:Calendar) getTimeInMillis*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) getTimeZone*() : TimeZone,NEW,EXTENSIBLE;

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

PROCEDURE (self:Calendar) internalGet!(p0 : INTEGER) : INTEGER,NEW;

PROCEDURE (self:Calendar) isLenient*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) isSet*(p0 : INTEGER) : BOOLEAN,NEW;

PROCEDURE (self:Calendar) roll*(p0 : INTEGER;
                                p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) roll*(p0 : INTEGER;
                                p1 : BOOLEAN),NEW,ABSTRACT;

PROCEDURE (self:Calendar) set*(p0 : INTEGER;
                               p1 : INTEGER;
                               p2 : INTEGER;
                               p3 : INTEGER;
                               p4 : INTEGER),NEW;

PROCEDURE (self:Calendar) set*(p0 : INTEGER;
                               p1 : INTEGER;
                               p2 : INTEGER;
                               p3 : INTEGER;
                               p4 : INTEGER;
                               p5 : INTEGER),NEW;

PROCEDURE (self:Calendar) set*(p0 : INTEGER;
                               p1 : INTEGER;
                               p2 : INTEGER),NEW;

PROCEDURE (self:Calendar) set*(p0 : INTEGER;
                               p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) setFirstDayOfWeek*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) setLenient*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) setMinimalDaysInFirstWeek*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) setTime*(p0 : Date),NEW;

PROCEDURE (self:Calendar) setTimeInMillis*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:Calendar) setTimeZone*(p0 : TimeZone),NEW,EXTENSIBLE;

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

PROCEDURE (self:Collection) add*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) addAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) clear*(),NEW,ABSTRACT;

PROCEDURE (self:Collection) contains*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) containsAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:Collection) hashCode*() : INTEGER,ABSTRACT;

PROCEDURE (self:Collection) isEmpty*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) iterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:Collection) remove*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) removeAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) retainAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Collection) size*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Collection) toArray*() : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Collection) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Comparator) compare*(p0 : java_lang.Object;
                                     p1 : java_lang.Object) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Comparator) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:Currency) getCurrencyCode*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Currency) getDefaultFractionDigits*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Currency) getSymbol*(p0 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Currency) getSymbol*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:Date) after*(p0 : Date) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Date) before*(p0 : Date) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Date) clone*() : java_lang.Object,EXTENSIBLE;

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

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

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

PROCEDURE (self:Date) getDate*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getDay*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getHours*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getMinutes*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getMonth*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getSeconds*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getTime*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getTimezoneOffset*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Date) getYear*() : INTEGER,NEW,EXTENSIBLE;

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

PROCEDURE (self:Date) setDate*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Date) setHours*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Date) setMinutes*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Date) setMonth*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Date) setSeconds*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Date) setTime*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:Date) setYear*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Date) toGMTString*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Date) toLocaleString*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:Deque) add*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) addFirst*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:Deque) addLast*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:Deque) contains*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) descendingIterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:Deque) element*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) getFirst*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) getLast*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) iterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:Deque) offer*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) offerFirst*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) offerLast*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) peek*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) peekFirst*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) peekLast*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) poll*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) pollFirst*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) pollLast*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) pop*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) push*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:Deque) remove*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) remove*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) removeFirst*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) removeFirstOccurrence*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) removeLast*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Deque) removeLastOccurrence*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Deque) size*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Dictionary) elements*() : Enumeration,NEW,ABSTRACT;

PROCEDURE (self:Dictionary) get*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Dictionary) isEmpty*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Dictionary) keys*() : Enumeration,NEW,ABSTRACT;

PROCEDURE (self:Dictionary) put*(p0 : java_lang.Object;
                                 p1 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Dictionary) remove*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Dictionary) size*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:DuplicateFormatFlagsException) getFlags*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:Enumeration) hasMoreElements*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Enumeration) nextElement*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:EnumMap) clear*(),EXTENSIBLE;

PROCEDURE (self:EnumMap) clone*() : EnumMap,NEW,EXTENSIBLE;

PROCEDURE (self:EnumMap) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:EnumMap) containsKey*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:EnumMap) containsValue*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:EnumMap) entrySet*() : Set,EXTENSIBLE;

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

PROCEDURE (self:EnumMap) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:EnumMap) keySet*() : Set,EXTENSIBLE;

PROCEDURE (self:EnumMap) put*(p0 : java_lang.Object;
                              p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:EnumMap) put*(p0 : java_lang.Enum;
                              p1 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:EnumMap) putAll*(p0 : Map),EXTENSIBLE;

PROCEDURE (self:EnumMap) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:EnumMap) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:EnumMap) values*() : Collection,EXTENSIBLE;

PROCEDURE (self:EnumSet) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:EnumSet) clone*() : EnumSet,NEW,EXTENSIBLE;

PROCEDURE (self:EventListenerProxy) getListener*() : EventListener,NEW,EXTENSIBLE;

PROCEDURE (self:EventObject) getSource*() : java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:FormatFlagsConversionMismatchException) getConversion*() : CHAR,NEW,EXTENSIBLE;

PROCEDURE (self:FormatFlagsConversionMismatchException) getFlags*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:Formattable) formatTo*(p0 : Formatter;
                                       p1 : INTEGER;
                                       p2 : INTEGER;
                                       p3 : INTEGER),NEW,ABSTRACT;

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

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

PROCEDURE (self:Formatter) format*(    p0 : java_lang.String;
                                   IN  p1 : ARRAY OF java_lang.Object) : Formatter,NEW,EXTENSIBLE;

PROCEDURE (self:Formatter) format*(    p0 : Locale;
                                       p1 : java_lang.String;
                                   IN  p2 : ARRAY OF java_lang.Object) : Formatter,NEW,EXTENSIBLE;

PROCEDURE (self:Formatter) ioException*() : java_io.IOException,NEW,EXTENSIBLE;

PROCEDURE (self:Formatter) locale*() : Locale,NEW,EXTENSIBLE;

PROCEDURE (self:Formatter) out*() : java_lang.Appendable,NEW,EXTENSIBLE;

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

PROCEDURE (self:GregorianCalendar) add*(p0 : INTEGER;
                                        p1 : INTEGER),EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) computeFields!(),EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) computeTime!(),EXTENSIBLE;

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

PROCEDURE (self:GregorianCalendar) getActualMaximum*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) getActualMinimum*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) getGreatestMinimum*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) getGregorianChange*() : Date,NEW;

PROCEDURE (self:GregorianCalendar) getLeastMaximum*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) getMaximum*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) getMinimum*(p0 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) getTimeZone*() : TimeZone,EXTENSIBLE;

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

PROCEDURE (self:GregorianCalendar) isLeapYear*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) roll*(p0 : INTEGER;
                                         p1 : INTEGER),EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) roll*(p0 : INTEGER;
                                         p1 : BOOLEAN),EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) setGregorianChange*(p0 : Date),NEW,EXTENSIBLE;

PROCEDURE (self:GregorianCalendar) setTimeZone*(p0 : TimeZone),EXTENSIBLE;

PROCEDURE (self:HashMap) clear*(),EXTENSIBLE;

PROCEDURE (self:HashMap) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:HashMap) containsKey*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:HashMap) containsValue*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:HashMap) entrySet*() : Set,EXTENSIBLE;

PROCEDURE (self:HashMap) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:HashMap) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:HashMap) keySet*() : Set,EXTENSIBLE;

PROCEDURE (self:HashMap) put*(p0 : java_lang.Object;
                              p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:HashMap) putAll*(p0 : Map),EXTENSIBLE;

PROCEDURE (self:HashMap) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:HashMap) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:HashMap) values*() : Collection,EXTENSIBLE;

PROCEDURE (self:HashSet) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:HashSet) clear*(),EXTENSIBLE;

PROCEDURE (self:HashSet) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:HashSet) contains*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:HashSet) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:HashSet) iterator*() : Iterator,EXTENSIBLE;

PROCEDURE (self:HashSet) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:HashSet) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:Hashtable) clear*(),NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Hashtable) contains*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) containsKey*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) containsValue*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) elements*() : Enumeration,EXTENSIBLE;

PROCEDURE (self:Hashtable) entrySet*() : Set,NEW,EXTENSIBLE;

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

PROCEDURE (self:Hashtable) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:Hashtable) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Hashtable) keys*() : Enumeration,EXTENSIBLE;

PROCEDURE (self:Hashtable) keySet*() : Set,NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) put*(p0 : java_lang.Object;
                                p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Hashtable) putAll*(p0 : Map),NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) rehash!(),NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Hashtable) size*() : INTEGER,EXTENSIBLE;

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

PROCEDURE (self:Hashtable) values*() : Collection,NEW,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) clear*(),EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) containsKey*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) containsValue*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) entrySet*() : Set,EXTENSIBLE;

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

PROCEDURE (self:IdentityHashMap) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:IdentityHashMap) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) keySet*() : Set,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) put*(p0 : java_lang.Object;
                                      p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) putAll*(p0 : Map),EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:IdentityHashMap) values*() : Collection,EXTENSIBLE;

PROCEDURE (self:IllegalFormatCodePointException) getCodePoint*() : INTEGER,NEW,EXTENSIBLE;

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

PROCEDURE (self:IllegalFormatConversionException) getArgumentClass*() : java_lang.Class,NEW,EXTENSIBLE;

PROCEDURE (self:IllegalFormatConversionException) getConversion*() : CHAR,NEW,EXTENSIBLE;

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

PROCEDURE (self:IllegalFormatFlagsException) getFlags*() : java_lang.String,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:IllegalFormatPrecisionException) getPrecision*() : INTEGER,NEW,EXTENSIBLE;

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

PROCEDURE (self:IllegalFormatWidthException) getWidth*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Iterator) hasNext*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Iterator) next*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Iterator) remove*(),NEW,ABSTRACT;

PROCEDURE (self:LinkedHashMap) clear*(),EXTENSIBLE;

PROCEDURE (self:LinkedHashMap) containsValue*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:LinkedHashMap) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:LinkedHashMap) removeEldestEntry!(p0 : Map$Entry) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:LinkedList) add*(p0 : INTEGER;
                                 p1 : java_lang.Object),EXTENSIBLE;

PROCEDURE (self:LinkedList) addAll*(p0 : INTEGER;
                                    p1 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:LinkedList) addAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:LinkedList) addFirst*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) addLast*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) clear*(),EXTENSIBLE;

PROCEDURE (self:LinkedList) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:LinkedList) contains*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:LinkedList) descendingIterator*() : Iterator,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) element*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) get*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:LinkedList) getFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) getLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) indexOf*(p0 : java_lang.Object) : INTEGER,EXTENSIBLE;

PROCEDURE (self:LinkedList) lastIndexOf*(p0 : java_lang.Object) : INTEGER,EXTENSIBLE;

PROCEDURE (self:LinkedList) listIterator*(p0 : INTEGER) : ListIterator,EXTENSIBLE;

PROCEDURE (self:LinkedList) offer*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) offerFirst*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) offerLast*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) peek*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) peekFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) peekLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) poll*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) pollFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) pollLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) pop*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) push*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) remove*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:LinkedList) remove*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:LinkedList) removeFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) removeFirstOccurrence*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) removeLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) removeLastOccurrence*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedList) set*(p0 : INTEGER;
                                 p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:LinkedList) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:LinkedList) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:LinkedList) toArray*() : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:List) add*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) add*(p0 : INTEGER;
                           p1 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:List) addAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) addAll*(p0 : INTEGER;
                              p1 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) clear*(),NEW,ABSTRACT;

PROCEDURE (self:List) contains*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) containsAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:List) get*(p0 : INTEGER) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:List) hashCode*() : INTEGER,ABSTRACT;

PROCEDURE (self:List) indexOf*(p0 : java_lang.Object) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:List) isEmpty*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) iterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:List) lastIndexOf*(p0 : java_lang.Object) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:List) listIterator*() : ListIterator,NEW,ABSTRACT;

PROCEDURE (self:List) listIterator*(p0 : INTEGER) : ListIterator,NEW,ABSTRACT;

PROCEDURE (self:List) remove*(p0 : INTEGER) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:List) remove*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) removeAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) retainAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:List) set*(p0 : INTEGER;
                           p1 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:List) size*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:List) subList*(p0 : INTEGER;
                               p1 : INTEGER) : List,NEW,ABSTRACT;

PROCEDURE (self:List) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:List) toArray*() : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ListIterator) add*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:ListIterator) hasNext*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ListIterator) hasPrevious*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ListIterator) next*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ListIterator) nextIndex*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ListIterator) previous*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ListIterator) previousIndex*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:ListIterator) remove*(),NEW,ABSTRACT;

PROCEDURE (self:ListIterator) set*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:ListResourceBundle) getContents!() : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ListResourceBundle) getKeys*() : Enumeration,EXTENSIBLE;

PROCEDURE (self:ListResourceBundle) handleGetObject*(p0 : java_lang.String) : java_lang.Object;

PROCEDURE (self:ListResourceBundle) handleKeySet!() : Set,EXTENSIBLE;

PROCEDURE (self:Locale) clone*() : java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:Locale) getCountry*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getDisplayCountry*() : java_lang.String,NEW;

PROCEDURE (self:Locale) getDisplayCountry*(p0 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getDisplayLanguage*(p0 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getDisplayLanguage*() : java_lang.String,NEW;

PROCEDURE (self:Locale) getDisplayName*() : java_lang.String,NEW;

PROCEDURE (self:Locale) getDisplayName*(p0 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getDisplayVariant*(p0 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getDisplayVariant*() : java_lang.String,NEW;

PROCEDURE (self:Locale) getISO3Country*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getISO3Language*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getLanguage*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Locale) getVariant*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:Locale) toString*() : java_lang.String;

PROCEDURE (self:Map) clear*(),NEW,ABSTRACT;

PROCEDURE (self:Map) containsKey*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Map) containsValue*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Map) entrySet*() : Set,NEW,ABSTRACT;

PROCEDURE (self:Map) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:Map) get*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Map) hashCode*() : INTEGER,ABSTRACT;

PROCEDURE (self:Map) isEmpty*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Map) keySet*() : Set,NEW,ABSTRACT;

PROCEDURE (self:Map) put*(p0 : java_lang.Object;
                          p1 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Map) putAll*(p0 : Map),NEW,ABSTRACT;

PROCEDURE (self:Map) remove*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Map) size*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Map) values*() : Collection,NEW,ABSTRACT;

PROCEDURE (self:Map$Entry) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:Map$Entry) getKey*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Map$Entry) getValue*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Map$Entry) hashCode*() : INTEGER,ABSTRACT;

PROCEDURE (self:Map$Entry) setValue*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:MissingFormatArgumentException) getFormatSpecifier*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:MissingFormatWidthException) getFormatSpecifier*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:MissingResourceException) getClassName*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:MissingResourceException) getKey*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:NavigableMap) ceilingEntry*(p0 : java_lang.Object) : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) ceilingKey*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) descendingKeySet*() : NavigableSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) descendingMap*() : NavigableMap,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) firstEntry*() : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) floorEntry*(p0 : java_lang.Object) : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) floorKey*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) headMap*(p0 : java_lang.Object;
                                       p1 : BOOLEAN) : NavigableMap,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) headMap*(p0 : java_lang.Object) : SortedMap,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) higherEntry*(p0 : java_lang.Object) : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) higherKey*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) lastEntry*() : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) lowerEntry*(p0 : java_lang.Object) : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) lowerKey*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) navigableKeySet*() : NavigableSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) pollFirstEntry*() : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) pollLastEntry*() : Map$Entry,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) subMap*(p0 : java_lang.Object;
                                      p1 : java_lang.Object) : SortedMap,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) subMap*(p0 : java_lang.Object;
                                      p1 : BOOLEAN;
                                      p2 : java_lang.Object;
                                      p3 : BOOLEAN) : NavigableMap,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) tailMap*(p0 : java_lang.Object) : SortedMap,NEW,ABSTRACT;

PROCEDURE (self:NavigableMap) tailMap*(p0 : java_lang.Object;
                                       p1 : BOOLEAN) : NavigableMap,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) ceiling*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) descendingIterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) descendingSet*() : NavigableSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) floor*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) headSet*(p0 : java_lang.Object;
                                       p1 : BOOLEAN) : NavigableSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) headSet*(p0 : java_lang.Object) : SortedSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) higher*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) iterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) lower*(p0 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) pollFirst*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) pollLast*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) subSet*(p0 : java_lang.Object;
                                      p1 : java_lang.Object) : SortedSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) subSet*(p0 : java_lang.Object;
                                      p1 : BOOLEAN;
                                      p2 : java_lang.Object;
                                      p3 : BOOLEAN) : NavigableSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) tailSet*(p0 : java_lang.Object) : SortedSet,NEW,ABSTRACT;

PROCEDURE (self:NavigableSet) tailSet*(p0 : java_lang.Object;
                                       p1 : BOOLEAN) : NavigableSet,NEW,ABSTRACT;

PROCEDURE (self:Observable) addObserver*(p0 : Observer),NEW,EXTENSIBLE;

PROCEDURE (self:Observable) clearChanged!(),NEW,EXTENSIBLE;

PROCEDURE (self:Observable) countObservers*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Observable) deleteObserver*(p0 : Observer),NEW,EXTENSIBLE;

PROCEDURE (self:Observable) deleteObservers*(),NEW,EXTENSIBLE;

PROCEDURE (self:Observable) hasChanged*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Observable) notifyObservers*(),NEW,EXTENSIBLE;

PROCEDURE (self:Observable) notifyObservers*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:Observable) setChanged!(),NEW,EXTENSIBLE;

PROCEDURE (self:Observer) update*(p0 : Observable;
                                  p1 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:PriorityQueue) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) clear*(),EXTENSIBLE;

PROCEDURE (self:PriorityQueue) comparator*() : Comparator,NEW,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) contains*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) iterator*() : Iterator,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) offer*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) peek*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) poll*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) toArray*() : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:PriorityQueue) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Properties) getProperty*(p0 : java_lang.String;
                                         p1 : java_lang.String) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Properties) getProperty*(p0 : java_lang.String) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Properties) list*(p0 : java_io.PrintWriter),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) list*(p0 : java_io.PrintStream),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) load*(p0 : java_io.Reader),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) load*(p0 : java_io.InputStream),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) loadFromXML*(p0 : java_io.InputStream),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) propertyNames*() : Enumeration,NEW,EXTENSIBLE;

PROCEDURE (self:Properties) save*(p0 : java_io.OutputStream;
                                  p1 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) setProperty*(p0 : java_lang.String;
                                         p1 : java_lang.String) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Properties) store*(p0 : java_io.Writer;
                                   p1 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) store*(p0 : java_io.OutputStream;
                                   p1 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) storeToXML*(p0 : java_io.OutputStream;
                                        p1 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) storeToXML*(p0 : java_io.OutputStream;
                                        p1 : java_lang.String;
                                        p2 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:Properties) stringPropertyNames*() : Set,NEW,EXTENSIBLE;

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

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

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

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

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

PROCEDURE (self:PropertyResourceBundle) getKeys*() : Enumeration,EXTENSIBLE;

PROCEDURE (self:PropertyResourceBundle) handleGetObject*(p0 : java_lang.String) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:PropertyResourceBundle) handleKeySet!() : Set,EXTENSIBLE;

PROCEDURE (self:Queue) add*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Queue) element*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Queue) offer*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Queue) peek*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Queue) poll*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Queue) remove*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Random) next!(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextBoolean*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextBytes*(IN  p0 : ARRAY OF BYTE),NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextDouble*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextFloat*() : SHORTREAL,NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextGaussian*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextInt*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextInt*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Random) nextLong*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:Random) setSeed*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle) containsKey*(p0 : java_lang.String) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle) getKeys*() : Enumeration,NEW,ABSTRACT;

PROCEDURE (self:ResourceBundle) getLocale*() : Locale,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle) getObject*(p0 : java_lang.String) : java_lang.Object,NEW;

PROCEDURE (self:ResourceBundle) getString*(p0 : java_lang.String) : java_lang.String,NEW;

PROCEDURE (self:ResourceBundle) getStringArray*(p0 : java_lang.String) : POINTER TO ARRAY OF java_lang.String,NEW;

PROCEDURE (self:ResourceBundle) handleGetObject!(p0 : java_lang.String) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ResourceBundle) handleKeySet!() : Set,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle) keySet*() : Set,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle) setParent!(p0 : ResourceBundle),NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) getCandidateLocales*(p0 : java_lang.String;
                                                             p1 : Locale) : List,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) getFallbackLocale*(p0 : java_lang.String;
                                                           p1 : Locale) : Locale,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) getFormats*(p0 : java_lang.String) : List,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) getTimeToLive*(p0 : java_lang.String;
                                                       p1 : Locale) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) needsReload*(p0 : java_lang.String;
                                                     p1 : Locale;
                                                     p2 : java_lang.String;
                                                     p3 : java_lang.ClassLoader;
                                                     p4 : ResourceBundle;
                                                     p5 : LONGINT) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) newBundle*(p0 : java_lang.String;
                                                   p1 : Locale;
                                                   p2 : java_lang.String;
                                                   p3 : java_lang.ClassLoader;
                                                   p4 : BOOLEAN) : ResourceBundle,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) toBundleName*(p0 : java_lang.String;
                                                      p1 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:ResourceBundle$Control) toResourceName*(p0 : java_lang.String;
                                                        p1 : java_lang.String) : java_lang.String,NEW;

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

PROCEDURE (self:Scanner) delimiter*() : java_util_regex.Pattern,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) findInLine*(p0 : java_util_regex.Pattern) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) findInLine*(p0 : java_lang.String) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) findWithinHorizon*(p0 : java_util_regex.Pattern;
                                            p1 : INTEGER) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) findWithinHorizon*(p0 : java_lang.String;
                                            p1 : INTEGER) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNext*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNext*(p0 : java_lang.String) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNext*(p0 : java_util_regex.Pattern) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextBigDecimal*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextBigInteger*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextBigInteger*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextBoolean*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextByte*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextByte*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextDouble*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextFloat*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextInt*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextInt*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextLine*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextLong*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextLong*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextShort*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) hasNextShort*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) ioException*() : java_io.IOException,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) locale*() : Locale,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) match*() : java_util_regex.MatchResult,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) next*(p0 : java_lang.String) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) next*(p0 : java_util_regex.Pattern) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) next*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) next*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextBigDecimal*() : java_math.BigDecimal,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextBigInteger*() : java_math.BigInteger,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextBigInteger*(p0 : INTEGER) : java_math.BigInteger,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextBoolean*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextByte*() : BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextByte*(p0 : INTEGER) : BYTE,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextDouble*() : REAL,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextFloat*() : SHORTREAL,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextInt*(p0 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextInt*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextLine*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextLong*(p0 : INTEGER) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextLong*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextShort*(p0 : INTEGER) : SHORTINT,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) nextShort*() : SHORTINT,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) radix*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) remove*(),NEW,EXTENSIBLE;

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

PROCEDURE (self:Scanner) skip*(p0 : java_util_regex.Pattern) : Scanner,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) skip*(p0 : java_lang.String) : Scanner,NEW,EXTENSIBLE;

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

PROCEDURE (self:Scanner) useDelimiter*(p0 : java_lang.String) : Scanner,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) useDelimiter*(p0 : java_util_regex.Pattern) : Scanner,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) useLocale*(p0 : Locale) : Scanner,NEW,EXTENSIBLE;

PROCEDURE (self:Scanner) useRadix*(p0 : INTEGER) : Scanner,NEW,EXTENSIBLE;

PROCEDURE (self:ServiceLoader) iterator*() : Iterator,NEW,EXTENSIBLE;

PROCEDURE (self:ServiceLoader) reload*(),NEW,EXTENSIBLE;

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

PROCEDURE (self:Set) add*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) addAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) clear*(),NEW,ABSTRACT;

PROCEDURE (self:Set) contains*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) containsAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) equals*(p0 : java_lang.Object) : BOOLEAN,ABSTRACT;

PROCEDURE (self:Set) hashCode*() : INTEGER,ABSTRACT;

PROCEDURE (self:Set) isEmpty*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) iterator*() : Iterator,NEW,ABSTRACT;

PROCEDURE (self:Set) remove*(p0 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) removeAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) retainAll*(p0 : Collection) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Set) size*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:Set) toArray*() : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Set) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SimpleTimeZone) clone*() : java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:SimpleTimeZone) getDSTSavings*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) getOffset*(p0 : LONGINT) : INTEGER,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) getOffset*(p0 : INTEGER;
                                           p1 : INTEGER;
                                           p2 : INTEGER;
                                           p3 : INTEGER;
                                           p4 : INTEGER;
                                           p5 : INTEGER) : INTEGER,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) getRawOffset*() : INTEGER,EXTENSIBLE;

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

PROCEDURE (self:SimpleTimeZone) hasSameRules*(p0 : TimeZone) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) inDaylightTime*(p0 : Date) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) setDSTSavings*(p0 : INTEGER),NEW,EXTENSIBLE;

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

PROCEDURE (self:SimpleTimeZone) setEndRule*(p0 : INTEGER;
                                            p1 : INTEGER;
                                            p2 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) setEndRule*(p0 : INTEGER;
                                            p1 : INTEGER;
                                            p2 : INTEGER;
                                            p3 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) setRawOffset*(p0 : INTEGER),EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) setStartRule*(p0 : INTEGER;
                                              p1 : INTEGER;
                                              p2 : INTEGER;
                                              p3 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) setStartRule*(p0 : INTEGER;
                                              p1 : INTEGER;
                                              p2 : INTEGER),NEW,EXTENSIBLE;

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

PROCEDURE (self:SimpleTimeZone) setStartYear*(p0 : INTEGER),NEW,EXTENSIBLE;

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

PROCEDURE (self:SimpleTimeZone) useDaylightTime*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:SortedMap) comparator*() : Comparator,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) entrySet*() : Set,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) firstKey*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) headMap*(p0 : java_lang.Object) : SortedMap,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) keySet*() : Set,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) lastKey*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) subMap*(p0 : java_lang.Object;
                                   p1 : java_lang.Object) : SortedMap,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) tailMap*(p0 : java_lang.Object) : SortedMap,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) values*() : Collection,NEW,ABSTRACT;

PROCEDURE (self:SortedSet) comparator*() : Comparator,NEW,ABSTRACT;

PROCEDURE (self:SortedSet) first*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SortedSet) headSet*(p0 : java_lang.Object) : SortedSet,NEW,ABSTRACT;

PROCEDURE (self:SortedSet) last*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SortedSet) subSet*(p0 : java_lang.Object;
                                   p1 : java_lang.Object) : SortedSet,NEW,ABSTRACT;

PROCEDURE (self:SortedSet) tailSet*(p0 : java_lang.Object) : SortedSet,NEW,ABSTRACT;

PROCEDURE (self:Stack) empty*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Stack) peek*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Stack) pop*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Stack) push*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Stack) search*(p0 : java_lang.Object) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:StringTokenizer) countTokens*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:StringTokenizer) hasMoreElements*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:StringTokenizer) hasMoreTokens*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:StringTokenizer) nextElement*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:StringTokenizer) nextToken*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:StringTokenizer) nextToken*(p0 : java_lang.String) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:Timer) cancel*(),NEW,EXTENSIBLE;

PROCEDURE (self:Timer) purge*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Timer) schedule*(p0 : TimerTask;
                                 p1 : Date;
                                 p2 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:Timer) schedule*(p0 : TimerTask;
                                 p1 : Date),NEW,EXTENSIBLE;

PROCEDURE (self:Timer) schedule*(p0 : TimerTask;
                                 p1 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:Timer) schedule*(p0 : TimerTask;
                                 p1 : LONGINT;
                                 p2 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:Timer) scheduleAtFixedRate*(p0 : TimerTask;
                                            p1 : LONGINT;
                                            p2 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:Timer) scheduleAtFixedRate*(p0 : TimerTask;
                                            p1 : Date;
                                            p2 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:TimerTask) cancel*() : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:TimerTask) scheduledExecutionTime*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeZone) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:TimeZone) getDisplayName*(p0 : Locale) : java_lang.String,NEW;

PROCEDURE (self:TimeZone) getDisplayName*() : java_lang.String,NEW;

PROCEDURE (self:TimeZone) getDisplayName*(p0 : BOOLEAN;
                                          p1 : INTEGER;
                                          p2 : Locale) : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:TimeZone) getDisplayName*(p0 : BOOLEAN;
                                          p1 : INTEGER) : java_lang.String,NEW;

PROCEDURE (self:TimeZone) getDSTSavings*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:TimeZone) getID*() : java_lang.String,NEW,EXTENSIBLE;

PROCEDURE (self:TimeZone) getOffset*(p0 : LONGINT) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:TimeZone) getOffset*(p0 : INTEGER;
                                     p1 : INTEGER;
                                     p2 : INTEGER;
                                     p3 : INTEGER;
                                     p4 : INTEGER;
                                     p5 : INTEGER) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:TimeZone) getRawOffset*() : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:TimeZone) hasSameRules*(p0 : TimeZone) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:TimeZone) inDaylightTime*(p0 : Date) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:TimeZone) setID*(p0 : java_lang.String),NEW,EXTENSIBLE;

PROCEDURE (self:TimeZone) setRawOffset*(p0 : INTEGER),NEW,ABSTRACT;

PROCEDURE (self:TimeZone) useDaylightTime*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:TreeMap) ceilingEntry*(p0 : java_lang.Object) : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) ceilingKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) clear*(),EXTENSIBLE;

PROCEDURE (self:TreeMap) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:TreeMap) comparator*() : Comparator,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) containsKey*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:TreeMap) containsValue*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:TreeMap) descendingKeySet*() : NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) descendingMap*() : NavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) entrySet*() : Set,EXTENSIBLE;

PROCEDURE (self:TreeMap) firstEntry*() : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) firstKey*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) floorEntry*(p0 : java_lang.Object) : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) floorKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:TreeMap) headMap*(p0 : java_lang.Object) : SortedMap,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) headMap*(p0 : java_lang.Object;
                                  p1 : BOOLEAN) : NavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) higherEntry*(p0 : java_lang.Object) : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) higherKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) keySet*() : Set,EXTENSIBLE;

PROCEDURE (self:TreeMap) lastEntry*() : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) lastKey*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) lowerEntry*(p0 : java_lang.Object) : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) lowerKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) navigableKeySet*() : NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) pollFirstEntry*() : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) pollLastEntry*() : Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) put*(p0 : java_lang.Object;
                              p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:TreeMap) putAll*(p0 : Map),EXTENSIBLE;

PROCEDURE (self:TreeMap) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:TreeMap) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:TreeMap) subMap*(p0 : java_lang.Object;
                                 p1 : java_lang.Object) : SortedMap,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) subMap*(p0 : java_lang.Object;
                                 p1 : BOOLEAN;
                                 p2 : java_lang.Object;
                                 p3 : BOOLEAN) : NavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) tailMap*(p0 : java_lang.Object) : SortedMap,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) tailMap*(p0 : java_lang.Object;
                                  p1 : BOOLEAN) : NavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:TreeMap) values*() : Collection,EXTENSIBLE;

PROCEDURE (self:TreeSet) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:TreeSet) addAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:TreeSet) ceiling*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) clear*(),EXTENSIBLE;

PROCEDURE (self:TreeSet) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:TreeSet) comparator*() : Comparator,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) contains*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:TreeSet) descendingIterator*() : Iterator,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) descendingSet*() : NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) first*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) floor*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) headSet*(p0 : java_lang.Object) : SortedSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) headSet*(p0 : java_lang.Object;
                                  p1 : BOOLEAN) : NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) higher*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:TreeSet) iterator*() : Iterator,EXTENSIBLE;

PROCEDURE (self:TreeSet) last*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) lower*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) pollFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) pollLast*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:TreeSet) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:TreeSet) subSet*(p0 : java_lang.Object;
                                 p1 : BOOLEAN;
                                 p2 : java_lang.Object;
                                 p3 : BOOLEAN) : NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) subSet*(p0 : java_lang.Object;
                                 p1 : java_lang.Object) : SortedSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) tailSet*(p0 : java_lang.Object;
                                  p1 : BOOLEAN) : NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) tailSet*(p0 : java_lang.Object) : SortedSet,NEW,EXTENSIBLE;

PROCEDURE (self:UnknownFormatConversionException) getConversion*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:UnknownFormatFlagsException) getFlags*() : java_lang.String,NEW,EXTENSIBLE;

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

PROCEDURE (self:UUID) clockSequence*() : INTEGER,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:UUID) getLeastSignificantBits*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:UUID) getMostSignificantBits*() : LONGINT,NEW,EXTENSIBLE;

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

PROCEDURE (self:UUID) node*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:UUID) timestamp*() : LONGINT,NEW,EXTENSIBLE;

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

PROCEDURE (self:UUID) variant*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:UUID) version*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Vector) add*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) add*(p0 : INTEGER;
                             p1 : java_lang.Object),EXTENSIBLE;

PROCEDURE (self:Vector) addAll*(p0 : INTEGER;
                                p1 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) addAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) addElement*(p0 : java_lang.Object),NEW,EXTENSIBLE;

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

PROCEDURE (self:Vector) clear*(),EXTENSIBLE;

PROCEDURE (self:Vector) clone*() : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Vector) contains*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) containsAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) copyInto*(IN  p0 : ARRAY OF java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:Vector) elementAt*(p0 : INTEGER) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Vector) elements*() : Enumeration,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:Vector) firstElement*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Vector) get*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:Vector) indexOf*(p0 : java_lang.Object) : INTEGER,EXTENSIBLE;

PROCEDURE (self:Vector) indexOf*(p0 : java_lang.Object;
                                 p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Vector) insertElementAt*(p0 : java_lang.Object;
                                         p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Vector) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) lastElement*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Vector) lastIndexOf*(p0 : java_lang.Object;
                                     p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Vector) lastIndexOf*(p0 : java_lang.Object) : INTEGER,EXTENSIBLE;

PROCEDURE (self:Vector) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) remove*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Vector) removeAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) removeAllElements*(),NEW,EXTENSIBLE;

PROCEDURE (self:Vector) removeElement*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Vector) removeElementAt*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Vector) removeRange!(p0 : INTEGER;
                                     p1 : INTEGER),EXTENSIBLE;

PROCEDURE (self:Vector) retainAll*(p0 : Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:Vector) set*(p0 : INTEGER;
                             p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Vector) setElementAt*(p0 : java_lang.Object;
                                      p1 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Vector) setSize*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Vector) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:Vector) subList*(p0 : INTEGER;
                                 p1 : INTEGER) : List,EXTENSIBLE;

PROCEDURE (self:Vector) toArray*() : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

PROCEDURE (self:Vector) toArray*(IN  p0 : ARRAY OF java_lang.Object) : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

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

PROCEDURE (self:Vector) trimToSize*(),NEW,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) clear*(),EXTENSIBLE;

PROCEDURE (self:WeakHashMap) containsKey*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) containsValue*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) entrySet*() : Set,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) get*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) isEmpty*() : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) keySet*() : Set,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) put*(p0 : java_lang.Object;
                                  p1 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) putAll*(p0 : Map),EXTENSIBLE;

PROCEDURE (self:WeakHashMap) remove*(p0 : java_lang.Object) : java_lang.Object,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) size*() : INTEGER,EXTENSIBLE;

PROCEDURE (self:WeakHashMap) values*() : Collection,EXTENSIBLE;

END java_util.