FOREIGN MODULE java_util_concurrent;

IMPORT
    java_lang := "java.lang",
    java_util := "java.util",
    java_io := "java.io",
    java_util_concurrent_locks := "java.util.concurrent.locks",
    sun_misc := "sun.misc",
    java_util_concurrent_atomic := "java.util.concurrent.atomic",
    java_security := "java.security";

TYPE

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

  ArrayBlockingQueue* = POINTER TO EXTENSIBLE RECORD (java_util.AbstractQueue + BlockingQueue + java_io.Serializable)    (* Typebound Procedures *)
                        STATIC
                          PROCEDURE Init*(p0 : INTEGER;
                                          p1 : BOOLEAN;
                                          p2 : java_util.Collection) : ArrayBlockingQueue,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : INTEGER;
                                          p1 : BOOLEAN) : ArrayBlockingQueue,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : INTEGER) : ArrayBlockingQueue,CONSTRUCTOR;
                        END;

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

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

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

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

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

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

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

  ConcurrentLinkedQueue* = POINTER TO EXTENSIBLE RECORD (java_util.AbstractQueue + java_util.Queue + java_io.Serializable)    (* Typebound Procedures *)
                           STATIC
                             PROCEDURE Init*(p0 : java_util.Collection) : ConcurrentLinkedQueue,CONSTRUCTOR;
                             PROCEDURE Init*() : ConcurrentLinkedQueue,CONSTRUCTOR;
                           END;

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

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

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

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

  CopyOnWriteArrayList* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + java_util.List + java_util.RandomAccess + java_lang.Cloneable + java_io.Serializable)    (* Typebound Procedures *)
                          STATIC
                            PROCEDURE Init*(IN  p0 : ARRAY OF java_lang.Object) : CopyOnWriteArrayList,CONSTRUCTOR;
                            PROCEDURE Init*(p0 : java_util.Collection) : CopyOnWriteArrayList,CONSTRUCTOR;
                            PROCEDURE Init*() : CopyOnWriteArrayList,CONSTRUCTOR;
                          END;

  CopyOnWriteArraySet* = POINTER TO EXTENSIBLE RECORD (java_util.AbstractSet + java_io.Serializable)    (* Typebound Procedures *)
                         STATIC
                           PROCEDURE Init*(p0 : java_util.Collection) : CopyOnWriteArraySet,CONSTRUCTOR;
                           PROCEDURE Init*() : CopyOnWriteArraySet,CONSTRUCTOR;
                         END;

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

  CyclicBarrier* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)    (* Typebound Procedures *)
                   STATIC
                     PROCEDURE Init*(p0 : INTEGER) : CyclicBarrier,CONSTRUCTOR;
                     PROCEDURE Init*(p0 : INTEGER;
                                     p1 : java_lang.Runnable) : CyclicBarrier,CONSTRUCTOR;
                   END;

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

  DelayQueue* = POINTER TO EXTENSIBLE RECORD (java_util.AbstractQueue + BlockingQueue)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE Init*(p0 : java_util.Collection) : DelayQueue,CONSTRUCTOR;
                  PROCEDURE Init*() : DelayQueue,CONSTRUCTOR;
                END;

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

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

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

  ExecutorCompletionService* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + CompletionService)    (* Typebound Procedures *)
                               STATIC
                                 PROCEDURE Init*(p0 : Executor;
                                                 p1 : BlockingQueue) : ExecutorCompletionService,CONSTRUCTOR;
                                 PROCEDURE Init*(p0 : Executor) : ExecutorCompletionService,CONSTRUCTOR;
                               END;

  Executors* = POINTER TO EXTENSIBLE RECORD (java_lang.Object)
               STATIC
                 PROCEDURE callable*(p0 : java_security.PrivilegedAction) : Callable;
                 PROCEDURE callable*(p0 : java_lang.Runnable) : Callable;
                 PROCEDURE callable*(p0 : java_security.PrivilegedExceptionAction) : Callable;
                 PROCEDURE callable*(p0 : java_lang.Runnable;
                                     p1 : java_lang.Object) : Callable;
                 PROCEDURE defaultThreadFactory*() : ThreadFactory;
                 PROCEDURE newCachedThreadPool*(p0 : ThreadFactory) : ExecutorService;
                 PROCEDURE newCachedThreadPool*() : ExecutorService;
                 PROCEDURE newFixedThreadPool*(p0 : INTEGER) : ExecutorService;
                 PROCEDURE newFixedThreadPool*(p0 : INTEGER;
                                               p1 : ThreadFactory) : ExecutorService;
                 PROCEDURE newScheduledThreadPool*(p0 : INTEGER;
                                                   p1 : ThreadFactory) : ScheduledExecutorService;
                 PROCEDURE newScheduledThreadPool*(p0 : INTEGER) : ScheduledExecutorService;
                 PROCEDURE newSingleThreadExecutor*(p0 : ThreadFactory) : ExecutorService;
                 PROCEDURE newSingleThreadExecutor*() : ExecutorService;
                 PROCEDURE newSingleThreadScheduledExecutor*() : ScheduledExecutorService;
                 PROCEDURE newSingleThreadScheduledExecutor*(p0 : ThreadFactory) : ScheduledExecutorService;
                 PROCEDURE privilegedCallable*(p0 : Callable) : Callable;
                 PROCEDURE privilegedCallableUsingCurrentClassLoader*(p0 : Callable) : Callable;
                 PROCEDURE privilegedThreadFactory*() : ThreadFactory;
                 PROCEDURE unconfigurableExecutorService*(p0 : ExecutorService) : ExecutorService;
                 PROCEDURE unconfigurableScheduledExecutorService*(p0 : ScheduledExecutorService) : ScheduledExecutorService;
               END;

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

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

  FutureTask* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + RunnableFuture)    (* Typebound Procedures *)
                STATIC
                  PROCEDURE Init*(p0 : java_lang.Runnable;
                                  p1 : java_lang.Object) : FutureTask,CONSTRUCTOR;
                  PROCEDURE Init*(p0 : Callable) : FutureTask,CONSTRUCTOR;
                END;

  LinkedBlockingDeque* = POINTER TO EXTENSIBLE RECORD (java_util.AbstractQueue + BlockingDeque + java_io.Serializable)    (* Typebound Procedures *)
                         STATIC
                           PROCEDURE Init*(p0 : java_util.Collection) : LinkedBlockingDeque,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : INTEGER) : LinkedBlockingDeque,CONSTRUCTOR;
                           PROCEDURE Init*() : LinkedBlockingDeque,CONSTRUCTOR;
                         END;

  LinkedBlockingQueue* = POINTER TO EXTENSIBLE RECORD (java_util.AbstractQueue + BlockingQueue + java_io.Serializable)    (* Typebound Procedures *)
                         STATIC
                           PROCEDURE Init*(p0 : java_util.Collection) : LinkedBlockingQueue,CONSTRUCTOR;
                           PROCEDURE Init*(p0 : INTEGER) : LinkedBlockingQueue,CONSTRUCTOR;
                           PROCEDURE Init*() : LinkedBlockingQueue,CONSTRUCTOR;
                         END;

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

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

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

  RunnableFuture* = POINTER TO INTERFACE RECORD (java_lang.Object + java_lang.Runnable + Future)    (* Typebound Procedures *)
                    END;

  RunnableScheduledFuture* = POINTER TO INTERFACE RECORD (java_lang.Object + RunnableFuture + ScheduledFuture)    (* Typebound Procedures *)
                             END;

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

  ScheduledFuture* = POINTER TO INTERFACE RECORD (java_lang.Object + Delayed + Future)
                     END;

  ScheduledThreadPoolExecutor* = POINTER TO EXTENSIBLE RECORD (ThreadPoolExecutor + ScheduledExecutorService)    (* Typebound Procedures *)
                                 STATIC
                                   PROCEDURE Init*(p0 : INTEGER;
                                                   p1 : RejectedExecutionHandler) : ScheduledThreadPoolExecutor,CONSTRUCTOR;
                                   PROCEDURE Init*(p0 : INTEGER;
                                                   p1 : ThreadFactory;
                                                   p2 : RejectedExecutionHandler) : ScheduledThreadPoolExecutor,CONSTRUCTOR;
                                   PROCEDURE Init*(p0 : INTEGER) : ScheduledThreadPoolExecutor,CONSTRUCTOR;
                                   PROCEDURE Init*(p0 : INTEGER;
                                                   p1 : ThreadFactory) : ScheduledThreadPoolExecutor,CONSTRUCTOR;
                                 END;

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

  SynchronousQueue* = POINTER TO EXTENSIBLE RECORD (java_util.AbstractQueue + BlockingQueue + java_io.Serializable)    (* Typebound Procedures *)
                      STATIC
                        PROCEDURE Init*(p0 : BOOLEAN) : SynchronousQueue,CONSTRUCTOR;
                        PROCEDURE Init*() : SynchronousQueue,CONSTRUCTOR;
                      END;

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

  ThreadPoolExecutor* = POINTER TO EXTENSIBLE RECORD (AbstractExecutorService)    (* Typebound Procedures *)
                        STATIC
                          PROCEDURE Init*(p0 : INTEGER;
                                          p1 : INTEGER;
                                          p2 : LONGINT;
                                          p3 : TimeUnit;
                                          p4 : BlockingQueue;
                                          p5 : RejectedExecutionHandler) : ThreadPoolExecutor,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : INTEGER;
                                          p1 : INTEGER;
                                          p2 : LONGINT;
                                          p3 : TimeUnit;
                                          p4 : BlockingQueue;
                                          p5 : ThreadFactory;
                                          p6 : RejectedExecutionHandler) : ThreadPoolExecutor,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : INTEGER;
                                          p1 : INTEGER;
                                          p2 : LONGINT;
                                          p3 : TimeUnit;
                                          p4 : BlockingQueue) : ThreadPoolExecutor,CONSTRUCTOR;
                          PROCEDURE Init*(p0 : INTEGER;
                                          p1 : INTEGER;
                                          p2 : LONGINT;
                                          p3 : TimeUnit;
                                          p4 : BlockingQueue;
                                          p5 : ThreadFactory) : ThreadPoolExecutor,CONSTRUCTOR;
                        END;

  ThreadPoolExecutor$AbortPolicy* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + RejectedExecutionHandler)    (* Typebound Procedures *)
                                    STATIC
                                      PROCEDURE Init*() : ThreadPoolExecutor$AbortPolicy,CONSTRUCTOR;
                                    END;

  ThreadPoolExecutor$CallerRunsPolicy* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + RejectedExecutionHandler)    (* Typebound Procedures *)
                                         STATIC
                                           PROCEDURE Init*() : ThreadPoolExecutor$CallerRunsPolicy,CONSTRUCTOR;
                                         END;

  ThreadPoolExecutor$DiscardOldestPolicy* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + RejectedExecutionHandler)    (* Typebound Procedures *)
                                            STATIC
                                              PROCEDURE Init*() : ThreadPoolExecutor$DiscardOldestPolicy,CONSTRUCTOR;
                                            END;

  ThreadPoolExecutor$DiscardPolicy* = POINTER TO EXTENSIBLE RECORD (java_lang.Object + RejectedExecutionHandler)    (* Typebound Procedures *)
                                      STATIC
                                        PROCEDURE Init*() : ThreadPoolExecutor$DiscardPolicy,CONSTRUCTOR;
                                      END;

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

  TimeUnit* = POINTER TO ABSTRACT RECORD (java_lang.Enum)    (* Typebound Procedures *)
              STATIC
                DAYS*         : TimeUnit;
                HOURS*        : TimeUnit;
                MICROSECONDS* : TimeUnit;
                MILLISECONDS* : TimeUnit;
                MINUTES*      : TimeUnit;
                NANOSECONDS*  : TimeUnit;
                SECONDS*      : TimeUnit;
                PROCEDURE valueOf*(p0 : java_lang.String) : TimeUnit;
                PROCEDURE values*() : POINTER TO ARRAY OF TimeUnit;
              END;




PROCEDURE (self:AbstractExecutorService) invokeAll*(p0 : java_util.Collection;
                                                    p1 : LONGINT;
                                                    p2 : TimeUnit) : java_util.List,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) invokeAll*(p0 : java_util.Collection) : java_util.List,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) invokeAny*(p0 : java_util.Collection;
                                                    p1 : LONGINT;
                                                    p2 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) invokeAny*(p0 : java_util.Collection) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) newTaskFor!(p0 : Callable) : RunnableFuture,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) newTaskFor!(p0 : java_lang.Runnable;
                                                     p1 : java_lang.Object) : RunnableFuture,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) submit*(p0 : java_lang.Runnable) : Future,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) submit*(p0 : java_lang.Runnable;
                                                 p1 : java_lang.Object) : Future,NEW,EXTENSIBLE;

PROCEDURE (self:AbstractExecutorService) submit*(p0 : Callable) : Future,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:ArrayBlockingQueue) drainTo*(p0 : java_util.Collection;
                                             p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayBlockingQueue) drainTo*(p0 : java_util.Collection) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ArrayBlockingQueue) iterator*() : java_util.Iterator,EXTENSIBLE;

PROCEDURE (self:ArrayBlockingQueue) offer*(p0 : java_lang.Object;
                                           p1 : LONGINT;
                                           p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ArrayBlockingQueue) poll*(p0 : LONGINT;
                                          p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ArrayBlockingQueue) remainingCapacity*() : INTEGER,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ArrayBlockingQueue) take*() : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

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

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

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

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

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

PROCEDURE (self:BlockingDeque) iterator*() : java_util.Iterator,NEW,ABSTRACT;

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

PROCEDURE (self:BlockingDeque) offer*(p0 : java_lang.Object;
                                      p1 : LONGINT;
                                      p2 : TimeUnit) : BOOLEAN,NEW,ABSTRACT;

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

PROCEDURE (self:BlockingDeque) offerFirst*(p0 : java_lang.Object;
                                           p1 : LONGINT;
                                           p2 : TimeUnit) : BOOLEAN,NEW,ABSTRACT;

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

PROCEDURE (self:BlockingDeque) offerLast*(p0 : java_lang.Object;
                                          p1 : LONGINT;
                                          p2 : TimeUnit) : BOOLEAN,NEW,ABSTRACT;

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

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

PROCEDURE (self:BlockingDeque) poll*(p0 : LONGINT;
                                     p1 : TimeUnit) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:BlockingDeque) pollFirst*(p0 : LONGINT;
                                          p1 : TimeUnit) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:BlockingDeque) pollLast*(p0 : LONGINT;
                                         p1 : TimeUnit) : java_lang.Object,NEW,ABSTRACT;

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

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

PROCEDURE (self:BlockingDeque) putFirst*(p0 : java_lang.Object),NEW,ABSTRACT;

PROCEDURE (self:BlockingDeque) putLast*(p0 : java_lang.Object),NEW,ABSTRACT;

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

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

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

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

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

PROCEDURE (self:BlockingDeque) take*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:BlockingDeque) takeFirst*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:BlockingDeque) takeLast*() : java_lang.Object,NEW,ABSTRACT;

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

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

PROCEDURE (self:BlockingQueue) drainTo*(p0 : java_util.Collection) : INTEGER,NEW,ABSTRACT;

PROCEDURE (self:BlockingQueue) drainTo*(p0 : java_util.Collection;
                                        p1 : INTEGER) : INTEGER,NEW,ABSTRACT;

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

PROCEDURE (self:BlockingQueue) offer*(p0 : java_lang.Object;
                                      p1 : LONGINT;
                                      p2 : TimeUnit) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:BlockingQueue) poll*(p0 : LONGINT;
                                     p1 : TimeUnit) : java_lang.Object,NEW,ABSTRACT;

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

PROCEDURE (self:BlockingQueue) remainingCapacity*() : INTEGER,NEW,ABSTRACT;

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

PROCEDURE (self:BlockingQueue) take*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:Callable) call*() : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:CompletionService) poll*(p0 : LONGINT;
                                         p1 : TimeUnit) : Future,NEW,ABSTRACT;

PROCEDURE (self:CompletionService) poll*() : Future,NEW,ABSTRACT;

PROCEDURE (self:CompletionService) submit*(p0 : Callable) : Future,NEW,ABSTRACT;

PROCEDURE (self:CompletionService) submit*(p0 : java_lang.Runnable;
                                           p1 : java_lang.Object) : Future,NEW,ABSTRACT;

PROCEDURE (self:CompletionService) take*() : Future,NEW,ABSTRACT;

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

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

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

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

PROCEDURE (self:ConcurrentHashMap) elements*() : java_util.Enumeration,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentHashMap) entrySet*() : java_util.Set,EXTENSIBLE;

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

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

PROCEDURE (self:ConcurrentHashMap) keys*() : java_util.Enumeration,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentHashMap) keySet*() : java_util.Set,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentHashMap) putAll*(p0 : java_util.Map),EXTENSIBLE;

PROCEDURE (self:ConcurrentHashMap) putIfAbsent*(p0 : java_lang.Object;
                                                p1 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ConcurrentHashMap) replace*(p0 : java_lang.Object;
                                            p1 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentHashMap) replace*(p0 : java_lang.Object;
                                            p1 : java_lang.Object;
                                            p2 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentHashMap) values*() : java_util.Collection,EXTENSIBLE;

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

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

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

PROCEDURE (self:ConcurrentLinkedQueue) iterator*() : java_util.Iterator,EXTENSIBLE;

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

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

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

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

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

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

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

PROCEDURE (self:ConcurrentMap) putIfAbsent*(p0 : java_lang.Object;
                                            p1 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

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

PROCEDURE (self:ConcurrentMap) replace*(p0 : java_lang.Object;
                                        p1 : java_lang.Object) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ConcurrentMap) replace*(p0 : java_lang.Object;
                                        p1 : java_lang.Object;
                                        p2 : java_lang.Object) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ConcurrentNavigableMap) descendingKeySet*() : java_util.NavigableSet,NEW,ABSTRACT;

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

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

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

PROCEDURE (self:ConcurrentNavigableMap) keySet*() : java_util.NavigableSet,NEW,ABSTRACT;

PROCEDURE (self:ConcurrentNavigableMap) navigableKeySet*() : java_util.NavigableSet,NEW,ABSTRACT;

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

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

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

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

PROCEDURE (self:ConcurrentSkipListMap) ceilingEntry*(p0 : java_lang.Object) : java_util.Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) ceilingKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:ConcurrentSkipListMap) comparator*() : java_util.Comparator,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ConcurrentSkipListMap) descendingKeySet*() : java_util.NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) descendingMap*() : ConcurrentNavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) descendingMap*() : java_util.NavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) entrySet*() : java_util.Set,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListMap) firstEntry*() : java_util.Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) firstKey*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) floorEntry*(p0 : java_lang.Object) : java_util.Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) floorKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListMap) headMap*(p0 : java_lang.Object) : java_util.SortedMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) headMap*(p0 : java_lang.Object;
                                                p1 : BOOLEAN) : ConcurrentNavigableMap,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListMap) headMap*(p0 : java_lang.Object) : ConcurrentNavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) higherEntry*(p0 : java_lang.Object) : java_util.Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) higherKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListMap) keySet*() : java_util.NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) keySet*() : java_util.Set,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) lastEntry*() : java_util.Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) lastKey*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) lowerEntry*(p0 : java_lang.Object) : java_util.Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) lowerKey*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) navigableKeySet*() : java_util.NavigableSet,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) pollFirstEntry*() : java_util.Map$Entry,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) pollLastEntry*() : java_util.Map$Entry,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListMap) putIfAbsent*(p0 : java_lang.Object;
                                                    p1 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ConcurrentSkipListMap) replace*(p0 : java_lang.Object;
                                                p1 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) replace*(p0 : java_lang.Object;
                                                p1 : java_lang.Object;
                                                p2 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ConcurrentSkipListMap) subMap*(p0 : java_lang.Object;
                                               p1 : java_lang.Object) : java_util.SortedMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) subMap*(p0 : java_lang.Object;
                                               p1 : java_lang.Object) : ConcurrentNavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) subMap*(p0 : java_lang.Object;
                                               p1 : BOOLEAN;
                                               p2 : java_lang.Object;
                                               p3 : BOOLEAN) : ConcurrentNavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) tailMap*(p0 : java_lang.Object) : ConcurrentNavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) tailMap*(p0 : java_lang.Object;
                                                p1 : BOOLEAN) : ConcurrentNavigableMap,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListMap) tailMap*(p0 : java_lang.Object) : java_util.SortedMap,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListMap) values*() : java_util.Collection,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListSet) ceiling*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:ConcurrentSkipListSet) comparator*() : java_util.Comparator,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListSet) descendingIterator*() : java_util.Iterator,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListSet) descendingSet*() : java_util.NavigableSet,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListSet) first*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListSet) floor*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListSet) headSet*(p0 : java_lang.Object) : java_util.NavigableSet,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListSet) headSet*(p0 : java_lang.Object) : java_util.SortedSet,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListSet) higher*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:ConcurrentSkipListSet) iterator*() : java_util.Iterator,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListSet) last*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:ConcurrentSkipListSet) lower*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:ConcurrentSkipListSet) removeAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

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

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

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

PROCEDURE (self:ConcurrentSkipListSet) subSet*(p0 : java_lang.Object;
                                               p1 : java_lang.Object) : java_util.NavigableSet,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ConcurrentSkipListSet) tailSet*(p0 : java_lang.Object) : java_util.NavigableSet,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:CopyOnWriteArrayList) addAll*(p0 : java_util.Collection) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CopyOnWriteArrayList) addAllAbsent*(p0 : java_util.Collection) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CopyOnWriteArrayList) addIfAbsent*(p0 : java_lang.Object) : BOOLEAN,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:CopyOnWriteArrayList) containsAll*(p0 : java_util.Collection) : BOOLEAN,NEW,EXTENSIBLE;

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

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

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

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

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

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

PROCEDURE (self:CopyOnWriteArrayList) iterator*() : java_util.Iterator,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:CopyOnWriteArrayList) listIterator*(p0 : INTEGER) : java_util.ListIterator,NEW,EXTENSIBLE;

PROCEDURE (self:CopyOnWriteArrayList) listIterator*() : java_util.ListIterator,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:CopyOnWriteArrayList) removeAll*(p0 : java_util.Collection) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CopyOnWriteArrayList) retainAll*(p0 : java_util.Collection) : BOOLEAN,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:CopyOnWriteArrayList) subList*(p0 : INTEGER;
                                               p1 : INTEGER) : java_util.List,NEW,EXTENSIBLE;

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

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

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

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

PROCEDURE (self:CopyOnWriteArraySet) addAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

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

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

PROCEDURE (self:CopyOnWriteArraySet) containsAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

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

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

PROCEDURE (self:CopyOnWriteArraySet) iterator*() : java_util.Iterator,EXTENSIBLE;

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

PROCEDURE (self:CopyOnWriteArraySet) removeAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:CopyOnWriteArraySet) retainAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

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

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

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

PROCEDURE (self:CountDownLatch) await*(p0 : LONGINT;
                                       p1 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:CountDownLatch) await*(),NEW,EXTENSIBLE;

PROCEDURE (self:CountDownLatch) countDown*(),NEW,EXTENSIBLE;

PROCEDURE (self:CountDownLatch) getCount*() : LONGINT,NEW,EXTENSIBLE;

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

PROCEDURE (self:CyclicBarrier) await*(p0 : LONGINT;
                                      p1 : TimeUnit) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CyclicBarrier) await*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CyclicBarrier) getNumberWaiting*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CyclicBarrier) getParties*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:CyclicBarrier) isBroken*() : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:Delayed) getDelay*(p0 : TimeUnit) : LONGINT,NEW,ABSTRACT;

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

PROCEDURE (self:DelayQueue) add*(p0 : Delayed) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:DelayQueue) drainTo*(p0 : java_util.Collection) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:DelayQueue) drainTo*(p0 : java_util.Collection;
                                     p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:DelayQueue) iterator*() : java_util.Iterator,EXTENSIBLE;

PROCEDURE (self:DelayQueue) offer*(p0 : java_lang.Object;
                                   p1 : LONGINT;
                                   p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:DelayQueue) offer*(p0 : Delayed) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:DelayQueue) offer*(p0 : Delayed;
                                   p1 : LONGINT;
                                   p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:DelayQueue) peek*() : Delayed,NEW,EXTENSIBLE;

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

PROCEDURE (self:DelayQueue) poll*(p0 : LONGINT;
                                  p1 : TimeUnit) : Delayed,NEW,EXTENSIBLE;

PROCEDURE (self:DelayQueue) poll*() : Delayed,NEW,EXTENSIBLE;

PROCEDURE (self:DelayQueue) poll*(p0 : LONGINT;
                                  p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:DelayQueue) put*(p0 : Delayed),NEW,EXTENSIBLE;

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

PROCEDURE (self:DelayQueue) remainingCapacity*() : INTEGER,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:DelayQueue) take*() : Delayed,NEW,EXTENSIBLE;

PROCEDURE (self:DelayQueue) take*() : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:Exchanger) exchange*(p0 : java_lang.Object;
                                     p1 : LONGINT;
                                     p2 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Exchanger) exchange*(p0 : java_lang.Object) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:Executor) execute*(p0 : java_lang.Runnable),NEW,ABSTRACT;

PROCEDURE (self:ExecutorCompletionService) poll*(p0 : LONGINT;
                                                 p1 : TimeUnit) : Future,NEW,EXTENSIBLE;

PROCEDURE (self:ExecutorCompletionService) poll*() : Future,NEW,EXTENSIBLE;

PROCEDURE (self:ExecutorCompletionService) submit*(p0 : Callable) : Future,NEW,EXTENSIBLE;

PROCEDURE (self:ExecutorCompletionService) submit*(p0 : java_lang.Runnable;
                                                   p1 : java_lang.Object) : Future,NEW,EXTENSIBLE;

PROCEDURE (self:ExecutorCompletionService) take*() : Future,NEW,EXTENSIBLE;

PROCEDURE (self:ExecutorService) awaitTermination*(p0 : LONGINT;
                                                   p1 : TimeUnit) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) invokeAll*(p0 : java_util.Collection;
                                            p1 : LONGINT;
                                            p2 : TimeUnit) : java_util.List,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) invokeAll*(p0 : java_util.Collection) : java_util.List,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) invokeAny*(p0 : java_util.Collection;
                                            p1 : LONGINT;
                                            p2 : TimeUnit) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) invokeAny*(p0 : java_util.Collection) : java_lang.Object,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) isShutdown*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) isTerminated*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) shutdown*(),NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) shutdownNow*() : java_util.List,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) submit*(p0 : Callable) : Future,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) submit*(p0 : java_lang.Runnable;
                                         p1 : java_lang.Object) : Future,NEW,ABSTRACT;

PROCEDURE (self:ExecutorService) submit*(p0 : java_lang.Runnable) : Future,NEW,ABSTRACT;

PROCEDURE (self:Future) cancel*(p0 : BOOLEAN) : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Future) get*(p0 : LONGINT;
                             p1 : TimeUnit) : java_lang.Object,NEW,ABSTRACT;

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

PROCEDURE (self:Future) isCancelled*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:Future) isDone*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:FutureTask) cancel*(p0 : BOOLEAN) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:FutureTask) done!(),NEW,EXTENSIBLE;

PROCEDURE (self:FutureTask) get*(p0 : LONGINT;
                                 p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:FutureTask) isCancelled*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:FutureTask) isDone*() : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:FutureTask) runAndReset!() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:FutureTask) set!(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:FutureTask) setException!(p0 : java_lang.Throwable),NEW,EXTENSIBLE;

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

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

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

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

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

PROCEDURE (self:LinkedBlockingDeque) descendingIterator*() : java_util.Iterator,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) drainTo*(p0 : java_util.Collection) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) drainTo*(p0 : java_util.Collection;
                                              p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:LinkedBlockingDeque) iterator*() : java_util.Iterator,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) offer*(p0 : java_lang.Object;
                                            p1 : LONGINT;
                                            p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:LinkedBlockingDeque) offerFirst*(p0 : java_lang.Object;
                                                 p1 : LONGINT;
                                                 p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:LinkedBlockingDeque) offerLast*(p0 : java_lang.Object;
                                                p1 : LONGINT;
                                                p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

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

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

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

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

PROCEDURE (self:LinkedBlockingDeque) poll*(p0 : LONGINT;
                                           p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) pollFirst*(p0 : LONGINT;
                                                p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:LinkedBlockingDeque) pollLast*(p0 : LONGINT;
                                               p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:LinkedBlockingDeque) putFirst*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) putLast*(p0 : java_lang.Object),NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) remainingCapacity*() : INTEGER,NEW,EXTENSIBLE;

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

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

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

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

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

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

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

PROCEDURE (self:LinkedBlockingDeque) take*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) takeFirst*() : java_lang.Object,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingDeque) takeLast*() : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

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

PROCEDURE (self:LinkedBlockingQueue) drainTo*(p0 : java_util.Collection) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingQueue) drainTo*(p0 : java_util.Collection;
                                              p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:LinkedBlockingQueue) iterator*() : java_util.Iterator,EXTENSIBLE;

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

PROCEDURE (self:LinkedBlockingQueue) offer*(p0 : java_lang.Object;
                                            p1 : LONGINT;
                                            p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:LinkedBlockingQueue) poll*(p0 : LONGINT;
                                           p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:LinkedBlockingQueue) remainingCapacity*() : INTEGER,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:LinkedBlockingQueue) take*() : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

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

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

PROCEDURE (self:PriorityBlockingQueue) comparator*() : java_util.Comparator,NEW,EXTENSIBLE;

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

PROCEDURE (self:PriorityBlockingQueue) drainTo*(p0 : java_util.Collection;
                                                p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:PriorityBlockingQueue) drainTo*(p0 : java_util.Collection) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:PriorityBlockingQueue) iterator*() : java_util.Iterator,EXTENSIBLE;

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

PROCEDURE (self:PriorityBlockingQueue) offer*(p0 : java_lang.Object;
                                              p1 : LONGINT;
                                              p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

PROCEDURE (self:PriorityBlockingQueue) poll*(p0 : LONGINT;
                                             p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:PriorityBlockingQueue) remainingCapacity*() : INTEGER,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:PriorityBlockingQueue) take*() : java_lang.Object,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:RejectedExecutionHandler) rejectedExecution*(p0 : java_lang.Runnable;
                                                             p1 : ThreadPoolExecutor),NEW,ABSTRACT;

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

PROCEDURE (self:RunnableScheduledFuture) isPeriodic*() : BOOLEAN,NEW,ABSTRACT;

PROCEDURE (self:ScheduledExecutorService) schedule*(p0 : Callable;
                                                    p1 : LONGINT;
                                                    p2 : TimeUnit) : ScheduledFuture,NEW,ABSTRACT;

PROCEDURE (self:ScheduledExecutorService) schedule*(p0 : java_lang.Runnable;
                                                    p1 : LONGINT;
                                                    p2 : TimeUnit) : ScheduledFuture,NEW,ABSTRACT;

PROCEDURE (self:ScheduledExecutorService) scheduleAtFixedRate*(p0 : java_lang.Runnable;
                                                               p1 : LONGINT;
                                                               p2 : LONGINT;
                                                               p3 : TimeUnit) : ScheduledFuture,NEW,ABSTRACT;

PROCEDURE (self:ScheduledExecutorService) scheduleWithFixedDelay*(p0 : java_lang.Runnable;
                                                                  p1 : LONGINT;
                                                                  p2 : LONGINT;
                                                                  p3 : TimeUnit) : ScheduledFuture,NEW,ABSTRACT;

PROCEDURE (self:ScheduledThreadPoolExecutor) decorateTask!(p0 : Callable;
                                                           p1 : RunnableScheduledFuture) : RunnableScheduledFuture,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) decorateTask!(p0 : java_lang.Runnable;
                                                           p1 : RunnableScheduledFuture) : RunnableScheduledFuture,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) execute*(p0 : java_lang.Runnable),EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) getContinueExistingPeriodicTasksAfterShutdownPolicy*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) getExecuteExistingDelayedTasksAfterShutdownPolicy*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) getQueue*() : BlockingQueue,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) remove*(p0 : java_lang.Runnable) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) schedule*(p0 : java_lang.Runnable;
                                                       p1 : LONGINT;
                                                       p2 : TimeUnit) : ScheduledFuture,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) schedule*(p0 : Callable;
                                                       p1 : LONGINT;
                                                       p2 : TimeUnit) : ScheduledFuture,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) scheduleAtFixedRate*(p0 : java_lang.Runnable;
                                                                  p1 : LONGINT;
                                                                  p2 : LONGINT;
                                                                  p3 : TimeUnit) : ScheduledFuture,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) scheduleWithFixedDelay*(p0 : java_lang.Runnable;
                                                                     p1 : LONGINT;
                                                                     p2 : LONGINT;
                                                                     p3 : TimeUnit) : ScheduledFuture,NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) setContinueExistingPeriodicTasksAfterShutdownPolicy*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) setExecuteExistingDelayedTasksAfterShutdownPolicy*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) shutdown*(),EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) shutdownNow*() : java_util.List,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) submit*(p0 : java_lang.Runnable) : Future,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) submit*(p0 : java_lang.Runnable;
                                                     p1 : java_lang.Object) : Future,EXTENSIBLE;

PROCEDURE (self:ScheduledThreadPoolExecutor) submit*(p0 : Callable) : Future,EXTENSIBLE;

PROCEDURE (self:Semaphore) acquire*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) acquire*(),NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) acquireUninterruptibly*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) acquireUninterruptibly*(),NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) availablePermits*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) drainPermits*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) getQueuedThreads!() : java_util.Collection,NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) getQueueLength*() : INTEGER,NEW;

PROCEDURE (self:Semaphore) hasQueuedThreads*() : BOOLEAN,NEW;

PROCEDURE (self:Semaphore) isFair*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) reducePermits!(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) release*(),NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) release*(p0 : INTEGER),NEW,EXTENSIBLE;

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

PROCEDURE (self:Semaphore) tryAcquire*(p0 : LONGINT;
                                       p1 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) tryAcquire*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) tryAcquire*(p0 : INTEGER;
                                       p1 : LONGINT;
                                       p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:Semaphore) tryAcquire*(p0 : INTEGER) : BOOLEAN,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:SynchronousQueue) containsAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:SynchronousQueue) drainTo*(p0 : java_util.Collection) : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:SynchronousQueue) drainTo*(p0 : java_util.Collection;
                                           p1 : INTEGER) : INTEGER,NEW,EXTENSIBLE;

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

PROCEDURE (self:SynchronousQueue) iterator*() : java_util.Iterator,EXTENSIBLE;

PROCEDURE (self:SynchronousQueue) offer*(p0 : java_lang.Object;
                                         p1 : LONGINT;
                                         p2 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

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

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

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

PROCEDURE (self:SynchronousQueue) poll*(p0 : LONGINT;
                                        p1 : TimeUnit) : java_lang.Object,NEW,EXTENSIBLE;

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

PROCEDURE (self:SynchronousQueue) remainingCapacity*() : INTEGER,NEW,EXTENSIBLE;

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

PROCEDURE (self:SynchronousQueue) removeAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

PROCEDURE (self:SynchronousQueue) retainAll*(p0 : java_util.Collection) : BOOLEAN,EXTENSIBLE;

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

PROCEDURE (self:SynchronousQueue) take*() : java_lang.Object,NEW,EXTENSIBLE;

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

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

PROCEDURE (self:ThreadFactory) newThread*(p0 : java_lang.Runnable) : java_lang.Thread,NEW,ABSTRACT;

PROCEDURE (self:ThreadPoolExecutor) afterExecute!(p0 : java_lang.Runnable;
                                                  p1 : java_lang.Throwable),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) allowCoreThreadTimeOut*(p0 : BOOLEAN),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) allowsCoreThreadTimeOut*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) awaitTermination*(p0 : LONGINT;
                                                      p1 : TimeUnit) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) beforeExecute!(p0 : java_lang.Thread;
                                                   p1 : java_lang.Runnable),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) execute*(p0 : java_lang.Runnable),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) finalize!(),EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getActiveCount*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getCompletedTaskCount*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getCorePoolSize*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getKeepAliveTime*(p0 : TimeUnit) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getLargestPoolSize*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getMaximumPoolSize*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getPoolSize*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getQueue*() : BlockingQueue,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getRejectedExecutionHandler*() : RejectedExecutionHandler,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getTaskCount*() : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) getThreadFactory*() : ThreadFactory,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) isShutdown*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) isTerminated*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) isTerminating*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) prestartAllCoreThreads*() : INTEGER,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) prestartCoreThread*() : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) purge*(),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) remove*(p0 : java_lang.Runnable) : BOOLEAN,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) setCorePoolSize*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) setKeepAliveTime*(p0 : LONGINT;
                                                      p1 : TimeUnit),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) setMaximumPoolSize*(p0 : INTEGER),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) setRejectedExecutionHandler*(p0 : RejectedExecutionHandler),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) setThreadFactory*(p0 : ThreadFactory),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) shutdown*(),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) shutdownNow*() : java_util.List,NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor) terminated!(),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor$AbortPolicy) rejectedExecution*(p0 : java_lang.Runnable;
                                                                   p1 : ThreadPoolExecutor),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor$CallerRunsPolicy) rejectedExecution*(p0 : java_lang.Runnable;
                                                                        p1 : ThreadPoolExecutor),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor$DiscardOldestPolicy) rejectedExecution*(p0 : java_lang.Runnable;
                                                                           p1 : ThreadPoolExecutor),NEW,EXTENSIBLE;

PROCEDURE (self:ThreadPoolExecutor$DiscardPolicy) rejectedExecution*(p0 : java_lang.Runnable;
                                                                     p1 : ThreadPoolExecutor),NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) convert*(p0 : LONGINT;
                                   p1 : TimeUnit) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) sleep*(p0 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) timedJoin*(p0 : java_lang.Thread;
                                     p1 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) timedWait*(p0 : java_lang.Object;
                                     p1 : LONGINT),NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) toDays*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) toHours*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) toMicros*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) toMillis*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) toMinutes*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) toNanos*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

PROCEDURE (self:TimeUnit) toSeconds*(p0 : LONGINT) : LONGINT,NEW,EXTENSIBLE;

END java_util_concurrent.