FOREIGN MODULE java_util;

IMPORT
    java_lang,
    java_io,
    java_lang_ref,
    java_text,
    java_security;

TYPE

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

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

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

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

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

  ArrayList* = POINTER TO EXTENSIBLE RECORD (AbstractList + List + java_lang.Cloneable + java_io.Serializable)
               STATIC
                 PROCEDURE Init*() : ArrayList,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : INTEGER) : ArrayList,CONSTRUCTOR;
                 PROCEDURE Init*(p0 : Collection) : 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 BYTE;
                                          p1 : BYTE) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF CHAR;
                                          p1 : CHAR) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF REAL;
                                          p1 : REAL) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF SHORTREAL;
                                          p1 : SHORTREAL) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF INTEGER;
                                          p1 : INTEGER) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF LONGINT;
                                          p1 : LONGINT) : 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 : java_lang.Object;
                                          p2 : Comparator) : INTEGER;
              PROCEDURE binarySearch*(IN  p0 : ARRAY OF SHORTINT;
                                          p1 : SHORTINT) : INTEGER;
              PROCEDURE equals*(IN  p0 : ARRAY OF BYTE;
                                IN  p1 : ARRAY OF BYTE) : 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 SHORTREAL;
                                IN  p1 : ARRAY OF SHORTREAL) : 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 java_lang.Object;
                                IN  p1 : ARRAY OF java_lang.Object) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF SHORTINT;
                                IN  p1 : ARRAY OF SHORTINT) : BOOLEAN;
              PROCEDURE equals*(IN  p0 : ARRAY OF BOOLEAN;
                                IN  p1 : ARRAY OF BOOLEAN) : BOOLEAN;
              PROCEDURE fill*(IN  p0 : ARRAY OF BYTE;
                                  p1 : BYTE);
              PROCEDURE fill*(IN  p0 : ARRAY OF BYTE;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : BYTE);
              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 REAL;
                                  p1 : REAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF REAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : REAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF SHORTREAL;
                                  p1 : SHORTREAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF SHORTREAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : SHORTREAL);
              PROCEDURE fill*(IN  p0 : ARRAY OF INTEGER;
                                  p1 : INTEGER);
              PROCEDURE fill*(IN  p0 : ARRAY OF INTEGER;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : INTEGER);
              PROCEDURE fill*(IN  p0 : ARRAY OF LONGINT;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : LONGINT);
              PROCEDURE fill*(IN  p0 : ARRAY OF LONGINT;
                                  p1 : LONGINT);
              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 SHORTINT;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : SHORTINT);
              PROCEDURE fill*(IN  p0 : ARRAY OF SHORTINT;
                                  p1 : SHORTINT);
              PROCEDURE fill*(IN  p0 : ARRAY OF BOOLEAN;
                                  p1 : INTEGER;
                                  p2 : INTEGER;
                                  p3 : BOOLEAN);
              PROCEDURE fill*(IN  p0 : ARRAY OF BOOLEAN;
                                  p1 : BOOLEAN);
              PROCEDURE sort*(IN  p0 : ARRAY OF BYTE);
              PROCEDURE sort*(IN  p0 : ARRAY OF BYTE;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF CHAR);
              PROCEDURE sort*(IN  p0 : ARRAY OF CHAR;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF REAL);
              PROCEDURE sort*(IN  p0 : ARRAY OF REAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF SHORTREAL);
              PROCEDURE sort*(IN  p0 : ARRAY OF SHORTREAL;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              PROCEDURE sort*(IN  p0 : ARRAY OF 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 java_lang.Object);
              PROCEDURE sort*(IN  p0 : ARRAY OF java_lang.Object;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
              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 SHORTINT);
              PROCEDURE sort*(IN  p0 : ARRAY OF SHORTINT;
                                  p1 : INTEGER;
                                  p2 : INTEGER);
            END;

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

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

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

  Collections* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
                 STATIC
                   EMPTY_SET* : Set;
                   EMPTY_LIST* : List;
                   PROCEDURE binarySearch*(p0 : List;
                                           p1 : java_lang.Object) : INTEGER;
                   PROCEDURE binarySearch*(p0 : List;
                                           p1 : java_lang.Object;
                                           p2 : Comparator) : INTEGER;
                   PROCEDURE copy*(p0 : List;
                                   p1 : List);
                   PROCEDURE enumeration*(p0 : Collection) : Enumeration;
                   PROCEDURE fill*(p0 : List;
                                   p1 : java_lang.Object);
                   PROCEDURE max*(p0 : Collection) : java_lang.Object;
                   PROCEDURE max*(p0 : Collection;
                                  p1 : Comparator) : java_lang.Object;
                   PROCEDURE min*(p0 : Collection) : java_lang.Object;
                   PROCEDURE min*(p0 : Collection;
                                  p1 : Comparator) : java_lang.Object;
                   PROCEDURE nCopies*(p0 : INTEGER;
                                      p1 : java_lang.Object) : List;
                   PROCEDURE reverse*(p0 : List);
                   PROCEDURE reverseOrder*() : Comparator;
                   PROCEDURE shuffle*(p0 : List);
                   PROCEDURE shuffle*(p0 : List;
                                      p1 : Random);
                   PROCEDURE singleton*(p0 : java_lang.Object) : Set;
                   PROCEDURE sort*(p0 : List);
                   PROCEDURE sort*(p0 : List;
                                   p1 : Comparator);
                   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)
                END;

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

  Date* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_io.Serializable + java_lang.Cloneable + java_lang.Comparable)
          STATIC
            PROCEDURE Init*() : Date,CONSTRUCTOR;
            PROCEDURE Init*(p0 : INTEGER;
                            p1 : INTEGER;
                            p2 : INTEGER) : Date,CONSTRUCTOR;
            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 : LONGINT) : Date,CONSTRUCTOR;
            PROCEDURE Init*(p0 : java_lang.String) : Date,CONSTRUCTOR;
            PROCEDURE UTC*(p0 : INTEGER;
                           p1 : INTEGER;
                           p2 : INTEGER;
                           p3 : INTEGER;
                           p4 : INTEGER;
                           p5 : INTEGER) : LONGINT;
            PROCEDURE parse*(p0 : java_lang.String) : LONGINT;
          END;

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

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

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

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

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

  GregorianCalendar* = POINTER TO EXTENSIBLE RECORD (Calendar)
                       STATIC
                         BC* = 0;
                         AD* = 1;
                         PROCEDURE Init*() : GregorianCalendar,CONSTRUCTOR;
                         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 : Locale) : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TimeZone) : GregorianCalendar,CONSTRUCTOR;
                         PROCEDURE Init*(p0 : TimeZone;
                                         p1 : Locale) : GregorianCalendar,CONSTRUCTOR;
                       END;

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

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

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

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

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

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

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

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

  Locale* = POINTER TO RECORD (java_lang.Object + java_lang.Cloneable + java_io.Serializable)
            STATIC
              ENGLISH* : Locale;
              FRENCH* : Locale;
              GERMAN* : Locale;
              ITALIAN* : Locale;
              JAPANESE* : Locale;
              KOREAN* : Locale;
              CHINESE* : Locale;
              SIMPLIFIED_CHINESE* : Locale;
              TRADITIONAL_CHINESE* : Locale;
              FRANCE* : Locale;
              GERMANY* : Locale;
              ITALY* : Locale;
              JAPAN* : Locale;
              KOREA* : Locale;
              CHINA* : Locale;
              PRC* : Locale;
              TAIWAN* : Locale;
              UK* : Locale;
              US* : Locale;
              CANADA* : Locale;
              CANADA_FRENCH* : Locale;
              PROCEDURE Init*(p0 : java_lang.String;
                              p1 : java_lang.String) : Locale,CONSTRUCTOR;
              PROCEDURE Init*(p0 : java_lang.String;
                              p1 : java_lang.String;
                              p2 : java_lang.String) : Locale,CONSTRUCTOR;
              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 setDefault*(p0 : Locale);
            END;

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

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

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

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

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

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

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

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

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

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

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

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

  SimpleTimeZone* = POINTER TO EXTENSIBLE RECORD (TimeZone)
                    STATIC
                      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;
                      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;
                    END;

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

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

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

  StringTokenizer* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + Enumeration)
                     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;

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

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

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

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

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

  WeakHashMap* = POINTER TO EXTENSIBLE RECORD (AbstractMap + Map)
                 STATIC
                   PROCEDURE Init*() : WeakHashMap,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER) : WeakHashMap,CONSTRUCTOR;
                   PROCEDURE Init*(p0 : INTEGER;
                                   p1 : SHORTREAL) : 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*() : ListIterator,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractList) listIterator*(p0 : INTEGER) : 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) 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: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:ArrayList) add*(p0 : INTEGER;
                                p1 : java_lang.Object),EXTENSIBLE;

PROCEDURE (self:ArrayList) add*(p0 : java_lang.Object) : BOOLEAN,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) 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) clear*(p0 : INTEGER),NEW,EXTENSIBLE;

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

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

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

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

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

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

PROCEDURE (self:BitSet) set*(p0 : INTEGER),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*(),NEW;

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

PROCEDURE (self:Calendar) clone*() : java_lang.Object,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;

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

PROCEDURE (self:Calendar) getActualMinimum*(p0 : INTEGER) : INTEGER,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),NEW;

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

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) 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: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: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:Enumeration) hasMoreElements*() : BOOLEAN,NEW,ABSTRACT;

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

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

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

PROCEDURE (self:GregorianCalendar) add*(p0 : INTEGER;
                                        p1 : INTEGER),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) 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: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) keySet*() : Set,NEW,EXTENSIBLE;

PROCEDURE (self:Hashtable) keys*() : Enumeration,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:Iterator) hasNext*() : BOOLEAN,NEW,ABSTRACT;

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

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

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

PROCEDURE (self:LinkedList) add*(p0 : java_lang.Object) : BOOLEAN,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) 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) remove*(p0 : INTEGER) : java_lang.Object,EXTENSIBLE;

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

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

PROCEDURE (self:LinkedList) removeLast*() : java_lang.Object,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*() : POINTER TO ARRAY OF java_lang.Object,EXTENSIBLE;

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

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

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

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

PROCEDURE (self:List) addAll*(p0 : 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*() : POINTER TO ARRAY OF java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:List) toArray*(IN  p0 : ARRAY OF java_lang.Object) : 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: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*() : java_lang.String,NEW;

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

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

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

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

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

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$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: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:MissingResourceException) getClassName*() : java_lang.String,NEW,EXTENSIBLE;

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

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:Properties) getProperty*(p0 : java_lang.String) : java_lang.String,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:Properties) load*(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.OutputStream;
                                   p1 : java_lang.String),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: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) 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) setParent!(p0 : ResourceBundle),NEW,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,NEW,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) hasSameRules*(p0 : TimeZone) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) hashCode*() : INTEGER,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),NEW,EXTENSIBLE;

PROCEDURE (self:SimpleTimeZone) setEndRule*(p0 : INTEGER;
                                            p1 : INTEGER;
                                            p2 : INTEGER;
                                            p3 : INTEGER),NEW,EXTENSIBLE;

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

PROCEDURE (self:SimpleTimeZone) setRawOffset*(p0 : INTEGER),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),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) firstKey*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:SortedMap) headMap*(p0 : java_lang.Object) : SortedMap,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: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:TimeZone) clone*() : java_lang.Object,EXTENSIBLE;

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

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

PROCEDURE (self:TimeZone) getDisplayName*(p0 : BOOLEAN;
                                          p1 : INTEGER) : java_lang.String,NEW;

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

PROCEDURE (self:TimeZone) getID*() : java_lang.String,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) 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) entrySet*() : Set,EXTENSIBLE;

PROCEDURE (self:TreeMap) firstKey*() : 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) keySet*() : Set,EXTENSIBLE;

PROCEDURE (self:TreeMap) lastKey*() : java_lang.Object,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) tailMap*(p0 : java_lang.Object) : SortedMap,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) 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) first*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:TreeSet) headSet*(p0 : java_lang.Object) : SortedSet,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) remove*(p0 : java_lang.Object) : BOOLEAN,EXTENSIBLE;

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

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

PROCEDURE (self:TreeSet) tailSet*(p0 : java_lang.Object) : SortedSet,NEW,EXTENSIBLE;

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

PROCEDURE (self:Vector) add*(p0 : java_lang.Object) : BOOLEAN,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) : INTEGER,EXTENSIBLE;

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

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

PROCEDURE (self:Vector) remove*(p0 : java_lang.Object) : BOOLEAN,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) entrySet*() : Set,EXTENSIBLE;

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

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

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

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

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

END java_util.