gistfile1.lisp

(defpackage :clisp-arglist
  (:use :cl)
  (:export :*arglist-list* :*arglist-map* :arglist))

(in-package :cl-user)

(defparameter clisp-arglist:*arglist-list*
'((* &REST #:ARGS)
  (+ &REST #:ARGS)
  (- NUMBER &REST #:MORE-NUMBERS)
  (/ NUMBER &REST #:MORE-NUMBERS)
  (/= NUMBER &REST #:MORE-NUMBERS)
  (1+ NUMBER)
  (1- NUMBER)
  (< NUMBER &REST #:MORE-NUMBERS)
  (<= NUMBER &REST #:MORE-NUMBERS)
  (= NUMBER &REST #:MORE-NUMBERS)
  (> NUMBER &REST #:MORE-NUMBERS)
  (>= NUMBER &REST #:MORE-NUMBERS)
  (ABORT &OPTIONAL CONDITION)
  (ABS NUMBER)
  (ACONS #:KEY #:DATUM #:ALIST)
  (ACOS NUMBER)
  (ACOSH NUMBER)
  (ADD-METHOD GENERIC-FUNCTION METHOD)
  (ADJOIN #:ITEM LIST &KEY #:KEY (#:TEST #'EQL #:TESTP) (#:TEST-NOT #:NIL #:NOTP))
  (ADJUST-ARRAY ARRAY #:DIMENSIONS &KEY
                (#:ELEMENT-TYPE (ARRAY-ELEMENT-TYPE ARRAY))
                (#:INITIAL-ELEMENT #:NIL #:INITIAL-ELEMENT-P)
                (#:INITIAL-CONTENTS #:NIL #:INITIAL-CONTENTS-P) FILL-POINTER
                #:DISPLACED-TO #:DISPLACED-INDEX-OFFSET)
  (ADJUSTABLE-ARRAY-P ARRAY)
  (ALLOCATE-INSTANCE CLASS &REST #:INITARGS)
  (ALPHA-CHAR-P CHAR)
  (ALPHANUMERICP CHAR)
  (AND &REST #:FORMS)
  (APPEND &REST #:LISTS)
  (APPLY FUNCTION #:ARG &REST #:ARGUMENTS)
  (APROPOS #:STRING-DESIGNATOR &OPTIONAL PACKAGE #:EXTERNAL-ONLY)
  (APROPOS-LIST #:STRING-DESIGNATOR &OPTIONAL #:PACKAGE-DESIGNATOR
                #:EXTERNAL-ONLY)
  (AREF ARRAY &REST #:SUBSCRIPTS)
  (ARITHMETIC-ERROR-OPERANDS CONDITION)
  (ARITHMETIC-ERROR-OPERATION CONDITION)
  (ARRAY-DIMENSION ARRAY #:AXIS-NUMBER)
  (ARRAY-DIMENSIONS ARRAY)
  (ARRAY-DISPLACEMENT ARRAY)
  (ARRAY-ELEMENT-TYPE ARRAY)
  (ARRAY-HAS-FILL-POINTER-P ARRAY)
  (ARRAY-IN-BOUNDS-P ARRAY &REST #:SUBSCRIPTS)
  (ARRAY-RANK ARRAY)
  (ARRAY-ROW-MAJOR-INDEX ARRAY &REST #:SUBSCRIPTS)
  (ARRAY-TOTAL-SIZE ARRAY)
  (ARRAYP #:OBJECT)
  (ASH INTEGER COUNT)
  (ASIN NUMBER)
  (ASINH NUMBER)
  (ASSERT #:TEST-FORM &OPTIONAL #:PLACES #:DATUM &REST #:ARGUMENTS)
  (ASSOC #:ITEM #:ALIST &KEY #:KEY (#:TEST #:NIL #:TESTP)
         (#:TEST-NOT #:NIL #:NOTP))
  (ASSOC-IF #:PREDICATE #:ALIST &KEY #:KEY)
  (ASSOC-IF-NOT #:PREDICATE #:ALIST &KEY #:KEY)
  (ATAN #:Y &OPTIONAL (#:X #:NIL #:XP))
  (ATANH NUMBER)
  (ATOM #:OBJECT)
  (BIT #:BIT-ARRAY &REST #:SUBSCRIPTS)
  (BIT-AND #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-ANDC1 #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-ANDC2 #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-EQV #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-IOR #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-NAND #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-NOR #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-NOT #:BIT-ARRAY &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-ORC1 #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-ORC2 #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BIT-VECTOR-P #:OBJECT)
  (BIT-XOR #:BIT-ARRAY-1 #:BIT-ARRAY-2 &OPTIONAL #:RESULT-BIT-ARRAY)
  (BLOCK #:NAME &REST #:FORMS)
  (BOOLE #:OP #:INTEGER1 #:INTEGER2)
  (BOTH-CASE-P CHAR)
  (BOUNDP SYMBOL)
  (BREAK &OPTIONAL (#:DATUM "break") &REST #:ARGUMENTS)
  (BROADCAST-STREAM-STREAMS #:INSTANCE)
  (BUTLAST LIST &OPTIONAL (#:N 1))
  (BYTE #:SIZE POSITION)
  (BYTE-POSITION #:BYTESPEC)
  (BYTE-SIZE #:BYTESPEC)
  (CAAAAR LIST)
  (CAAADR LIST)
  (CAAAR LIST)
  (CAADAR LIST)
  (CAADDR LIST)
  (CAADR LIST)
  (CAAR LIST)
  (CADAAR LIST)
  (CADADR LIST)
  (CADAR LIST)
  (CADDAR LIST)
  (CADDDR LIST)
  (CADDR LIST)
  (CADR LIST)
  (CALL-METHOD &REST #:ARGS)
  (CAR LIST)
  (CASE #:KEYFORM &BODY #:CASES)
  (CATCH #:TAG &BODY #:BODY)
  (CCASE #:KEYFORM &BODY #:CASES)
  (CDAAAR LIST)
  (CDAADR LIST)
  (CDAAR LIST)
  (CDADAR LIST)
  (CDADDR LIST)
  (CDADR LIST)
  (CDAR LIST)
  (CDDAAR LIST)
  (CDDADR LIST)
  (CDDAR LIST)
  (CDDDAR LIST)
  (CDDDDR LIST)
  (CDDDR LIST)
  (CDDR LIST)
  (CDR LIST)
  (CEILING NUMBER &OPTIONAL (#:DIVISOR 1))
  (CELL-ERROR-NAME CONDITION)
  (CERROR #:CONTINUE-STRING #:DATUM &REST #:ARGUMENTS)
  (CHANGE-CLASS #:INSTANCE #:NEW-CLASS-NAME &REST #:INITARGS &ALLOW-OTHER-KEYS)
  (CHAR STRING #:INDEX)
  (CHAR-CODE CHAR)
  (CHAR-DOWNCASE CHAR)
  (CHAR-EQUAL CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR-GREATERP CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR-INT CHAR)
  (CHAR-LESSP CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR-NAME CHAR)
  (CHAR-NOT-EQUAL CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR-NOT-GREATERP CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR-NOT-LESSP CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR-UPCASE CHAR)
  (CHAR/= CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR< CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR<= CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR= CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR> CHARACTER &REST #:MORE-CHARACTERS)
  (CHAR>= CHARACTER &REST #:MORE-CHARACTERS)
  (CHARACTER #:OBJECT)
  (CHARACTERP #:OBJECT)
  (CHECK-TYPE #:PLACE TYPE &OPTIONAL #:TYPE-STRING &ENVIRONMENT #:ENV)
  (CIS #:THETA)
  (CLASS-NAME CLASS)
  (CLASS-OF #:X)
  (CLEAR-INPUT &OPTIONAL (STREAM *STANDARD-INPUT*))
  (CLEAR-OUTPUT &OPTIONAL (STREAM *STANDARD-OUTPUT*))
  (CLOSE STREAM &KEY ABORT)
  (CLRHASH HASH-TABLE)
  (CODE-CHAR #:CODE)
  (COERCE #:OBJECT #:OUTPUT-TYPE-SPEC)
  (COMPILE #:NAME &OPTIONAL
           (#:DEFINITION (OR (MACRO-FUNCTION #:NAME) (FDEFINITION #:NAME))))
  (COMPILE-FILE #:INPUT-FILE &KEY
                (#:OUTPUT-FILE (#:CFP-OUTPUT-FILE-DEFAULT #:INPUT-FILE))
                ((:VERBOSE *COMPILE-VERBOSE*) *COMPILE-VERBOSE*)
                ((:PRINT *COMPILE-PRINT*) *COMPILE-PRINT*)
                (#:EXTERNAL-FORMAT :DEFAULT) (#:TRACE-FILE #:NIL)
                ((:BLOCK-COMPILE #:*BLOCK-COMPILE-ARG*) #:NIL))
  (COMPILE-FILE-PATHNAME #:INPUT-FILE &KEY (#:OUTPUT-FILE #:NIL #:OUTPUT-FILE-P)
                         &ALLOW-OTHER-KEYS)
  (COMPILED-FUNCTION-P #:OBJECT)
  (COMPILER-MACRO-FUNCTION #:NAME &OPTIONAL #:ENV)
  (COMPLEMENT FUNCTION)
  (COMPLEX REALPART &OPTIONAL (IMAGPART 0))
  (COMPLEXP #:OBJECT)
  (COMPUTE-APPLICABLE-METHODS GENERIC-FUNCTION #:ARGUMENTS)
  (COMPUTE-RESTARTS &OPTIONAL CONDITION)
  (CONCATENATE #:OUTPUT-TYPE-SPEC &REST #:SEQUENCES)
  (CONCATENATED-STREAM-STREAMS #:INSTANCE)
  (COND &REST #:CLAUSES)
  (CONJUGATE NUMBER)
  (CONS #:SE1 #:SE2)
  (CONSP #:OBJECT)
  (CONSTANTLY #:VALUE)
  (CONSTANTP #:FORM &OPTIONAL (#:ENVIRONMENT #:NIL #:ENVP))
  (CONTINUE &OPTIONAL CONDITION)
  (COPY-ALIST #:ALIST)
  (COPY-LIST LIST)
  (COPY-PPRINT-DISPATCH &OPTIONAL (#:TABLE *PRINT-PPRINT-DISPATCH*))
  (COPY-READTABLE &OPTIONAL (#:FROM-READTABLE *READTABLE*) #:TO-READTABLE)
  (COPY-SEQ SEQUENCE)
  (COPY-STRUCTURE STRUCTURE)
  (COPY-SYMBOL SYMBOL &OPTIONAL (#:COPY-PROPS #:NIL) &AUX #:NEW-SYMBOL)
  (COPY-TREE #:OBJECT)
  (COS NUMBER)
  (COSH NUMBER)
  (COUNT #:ITEM SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0) (#:END #:NIL)
         (#:KEY #:NIL) (#:TEST #'EQL #:TEST-P) (#:TEST-NOT #:NIL #:TEST-NOT-P))
  (COUNT-IF #:PRED SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
            (#:END #:NIL) (#:KEY #:NIL))
  (COUNT-IF-NOT #:PRED SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
                (#:END #:NIL) (#:KEY #:NIL))
  (CTYPECASE #:KEYFORM &BODY #:CASES)
  (DECF #:PLACE &OPTIONAL (#:DELTA 1) &ENVIRONMENT #:ENV)
  (DECLAIM &REST #:SPECS)
  (DECODE-FLOAT #:F)
  (DECODE-UNIVERSAL-TIME #:UNIVERSAL-TIME &OPTIONAL #:TIME-ZONE)
  (DEFCLASS &ENVIRONMENT #:ENV #:NAME #:DIRECT-SUPERCLASSES #:DIRECT-SLOTS &REST
            #:OPTIONS)
  (DEFCONSTANT #:NAME #:VALUE &OPTIONAL DOCUMENTATION)
  (DEFGENERIC #:FUN-NAME #:LAMBDA-LIST &BODY #:OPTIONS)
  (DEFINE-COMPILER-MACRO #:NAME #:LAMBDA-LIST &BODY #:BODY)
  (DEFINE-CONDITION #:NAME (&REST #:PARENT-TYPES) (&REST #:SLOT-SPECS) &BODY
                    #:OPTIONS)
  (DEFINE-METHOD-COMBINATION &WHOLE #:FORM &REST #:ARGS)
  (DEFINE-MODIFY-MACRO #:NAME #:LAMBDA-LIST FUNCTION &OPTIONAL #:DOC-STRING)
  (DEFINE-SETF-EXPANDER #:ACCESS-FN #:LAMBDA-LIST &BODY #:BODY)
  (DEFINE-SYMBOL-MACRO #:NAME #:EXPANSION)
  (DEFMACRO #:NAME #:LAMBDA-LIST &REST #:BODY)
  (DEFMETHOD &REST #:ARGS)
  (DEFPACKAGE PACKAGE
    &REST
    #:OPTIONS)
  (DEFPARAMETER #:VAR #:VAL &OPTIONAL (#:DOC #:NIL #:DOCP))
  (DEFSETF #:ACCESS-FN &REST REST)
  (DEFSTRUCT #:NAME-AND-OPTIONS &REST #:SLOT-DESCRIPTIONS)
  (DEFTYPE #:NAME #:LAMBDA-LIST &BODY #:BODY)
  (DEFUN &ENVIRONMENT #:ENV #:NAME #:ARGS &BODY #:BODY)
  (DEFVAR #:VAR &OPTIONAL (#:VAL #:NIL #:VALP) (#:DOC #:NIL #:DOCP))
  (DELETE #:ITEM SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:TEST #'EQL)
          (#:TEST-NOT #:NIL) (#:START 0) (#:END #:NIL) (COUNT #:NIL)
          (#:KEY #:NIL))
  (DELETE-DUPLICATES SEQUENCE &REST #:ARGS &KEY (#:TEST #'EQL) (#:TEST-NOT #:NIL)
                     (#:START 0) (#:END #:NIL) #:FROM-END (#:KEY #:NIL))
  (DELETE-FILE #:FILE)
  (DELETE-IF #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
             (#:KEY #:NIL) (#:END #:NIL) (COUNT #:NIL))
  (DELETE-IF-NOT #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
                 (#:END #:NIL) (#:KEY #:NIL) (COUNT #:NIL))
  (DELETE-PACKAGE #:PACKAGE-DESIGNATOR)
  (DENOMINATOR NUMBER)
  (DEPOSIT-FIELD #:NEWBYTE #:BYTESPEC INTEGER)
  (DESCRIBE #:X &OPTIONAL (#:STREAM-DESIGNATOR *STANDARD-OUTPUT*))
  (DESCRIBE-OBJECT #:X STREAM)
  (DESTRUCTURING-BIND #:LAMBDA-LIST #:EXPRESSION &BODY #:BODY)
  (DIGIT-CHAR #:WEIGHT &OPTIONAL (#:RADIX 10))
  (DIGIT-CHAR-P CHAR &OPTIONAL (#:RADIX 10))
  (DIRECTORY PATHNAME &KEY (#:RESOLVE-SYMLINKS T))
  (DIRECTORY-NAMESTRING PATHNAME)
  (DISASSEMBLE #:OBJECT &KEY (STREAM *STANDARD-OUTPUT*) (#:USE-LABELS T))
  (DO #:VARLIST #:ENDLIST &BODY #:BODY)
  (DO* #:VARLIST #:ENDLIST &BODY #:BODY)
  (DO-ALL-SYMBOLS (#:VAR &OPTIONAL #:RESULT-FORM) &BODY #:BODY-DECLS)
  (DO-EXTERNAL-SYMBOLS (#:VAR &OPTIONAL (PACKAGE '*PACKAGE*) #:RESULT-FORM)
   &BODY
   #:BODY-DECLS)
  (DO-SYMBOLS (#:VAR &OPTIONAL (PACKAGE '*PACKAGE*) #:RESULT-FORM)
   &BODY
   #:BODY-DECLS)
  (DOCUMENTATION #:SLOTD #:DOC-TYPE)
  (DOLIST (#:VAR LIST &OPTIONAL (#:RESULT #:NIL)) &BODY #:BODY &ENVIRONMENT #:ENV)
  (DOTIMES (#:VAR COUNT &OPTIONAL (#:RESULT #:NIL)) &BODY #:BODY)
  (DPB #:NEWBYTE #:BYTESPEC INTEGER)
  (DRIBBLE &OPTIONAL PATHNAME &KEY (#:IF-EXISTS :APPEND))
  (ECASE #:KEYFORM &BODY #:CASES)
  (ECHO-STREAM-INPUT-STREAM #:INSTANCE)
  (ECHO-STREAM-OUTPUT-STREAM #:INSTANCE)
  (ED &OPTIONAL #:X)
  (EIGHTH LIST)
  (ELT SEQUENCE #:INDEX)
  (ENCODE-UNIVERSAL-TIME SECOND #:MINUTE #:HOUR #:DATE #:MONTH #:YEAR &OPTIONAL
                         #:TIME-ZONE)
  (ENDP #:OBJECT)
  (ENOUGH-NAMESTRING PATHNAME &OPTIONAL (#:DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*))
  (ENSURE-DIRECTORIES-EXIST #:PATHSPEC &KEY #:VERBOSE (#:MODE 511))
  (ENSURE-GENERIC-FUNCTION #:FUN-NAME &REST #:ALL-KEYS &KEY #:ENVIRONMENT
                           #:SOURCE-LOCATION &ALLOW-OTHER-KEYS)
  (EQ #:OBJ1 #:OBJ2)
  (EQL #:X #:Y)
  (EQUAL #:X #:Y)
  (EQUALP #:X #:Y)
  (ERROR #:DATUM &REST #:ARGUMENTS)
  (ETYPECASE #:KEYFORM &BODY #:CASES)
  (EVAL #:ORIGINAL-EXP)
  (EVAL-WHEN #:SITUATIONS &REST #:FORMS)
  (EVENP NUMBER)
  (EVERY #:PRED #:FIRST-SEQ &REST #:MORE-SEQS)
  (EXP NUMBER)
  (EXPORT #:SYMBOLS &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (EXPT #:BASE #:POWER)
  (FBOUNDP #:NAME)
  (FCEILING NUMBER &OPTIONAL (#:DIVISOR 1))
  (FDEFINITION #:NAME)
  (FFLOOR NUMBER &OPTIONAL (#:DIVISOR 1))
  (FIFTH LIST)
  (FILE-AUTHOR #:PATHSPEC)
  (FILE-ERROR-PATHNAME CONDITION)
  (FILE-LENGTH STREAM)
  (FILE-NAMESTRING PATHNAME)
  (FILE-POSITION STREAM &OPTIONAL POSITION)
  (FILE-STRING-LENGTH STREAM #:OBJECT)
  (FILE-WRITE-DATE #:PATHSPEC)
  (FILL SEQUENCE #:ITEM &KEY (#:START 0) #:END)
  (FILL-POINTER VECTOR)
  (FIND #:ITEM SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0) #:END #:KEY
        #:TEST #:TEST-NOT)
  (FIND-ALL-SYMBOLS #:STRING-OR-SYMBOL)
  (FIND-CLASS SYMBOL &OPTIONAL (#:ERRORP T) #:ENVIRONMENT)
  (FIND-IF #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0) #:END
           #:KEY)
  (FIND-IF-NOT #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
               #:END #:KEY)
  (FIND-METHOD GENERIC-FUNCTION #:QUALIFIERS #:SPECIALIZERS &OPTIONAL #:ERRORP)
  (FIND-PACKAGE #:PACKAGE-DESIGNATOR)
  (FIND-RESTART #:IDENTIFIER &OPTIONAL CONDITION)
  (FIND-SYMBOL #:NAME &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (FINISH-OUTPUT &OPTIONAL (STREAM *STANDARD-OUTPUT*))
  (FIRST LIST)
  (FLET #:DEFINITIONS
    &BODY
    #:BODY)
  (FLOAT NUMBER &OPTIONAL (#:OTHER #:NIL #:OTHERP))
  (FLOAT-DIGITS #:F)
  (FLOAT-PRECISION #:F)
  (FLOAT-RADIX #:X)
  (FLOAT-SIGN #:FLOAT1 &OPTIONAL (#:FLOAT2 (FLOAT 1 #:FLOAT1)))
  (FLOATP #:OBJECT)
  (FLOOR NUMBER &OPTIONAL (#:DIVISOR 1))
  (FMAKUNBOUND #:NAME)
  (FORCE-OUTPUT &OPTIONAL (STREAM *STANDARD-OUTPUT*))
  (FORMAT #:DESTINATION #:CONTROL-STRING &REST #:FORMAT-ARGUMENTS)
  (FORMATTER #:CONTROL-STRING)
  (FOURTH LIST)
  (FRESH-LINE &OPTIONAL (STREAM *STANDARD-OUTPUT*))
  (FROUND NUMBER &OPTIONAL (#:DIVISOR 1))
  (FTRUNCATE NUMBER &OPTIONAL (#:DIVISOR 1))
  (FUNCALL FUNCTION &REST #:ARGUMENTS)
  #'#:THING
  (FUNCTION-KEYWORDS METHOD)
  (FUNCTION-LAMBDA-EXPRESSION #:FUN)
  (FUNCTIONP #:OBJECT)
  (GCD &REST #:INTEGERS)
  (GENSYM &OPTIONAL (#:THING "G"))
  (GENTEMP &OPTIONAL (#:PREFIX "T") (PACKAGE (#:SANE-PACKAGE)))
  (GET SYMBOL #:INDICATOR &OPTIONAL (#:DEFAULT #:NIL))
  (GET-DECODED-TIME)
  (GET-DISPATCH-MACRO-CHARACTER #:DISP-CHAR #:SUB-CHAR &OPTIONAL
                                (#:RT-DESIGNATOR *READTABLE*))
  (GET-INTERNAL-REAL-TIME)
  (GET-INTERNAL-RUN-TIME)
  (GET-MACRO-CHARACTER CHAR &OPTIONAL (#:RT-DESIGNATOR *READTABLE*))
  (GET-OUTPUT-STREAM-STRING STREAM)
  (GET-PROPERTIES #:PLACE #:INDICATOR-LIST)
  (GET-SETF-EXPANSION #:FORM &OPTIONAL #:ENVIRONMENT)
  (GET-UNIVERSAL-TIME)
  (GETF #:PLACE #:INDICATOR &OPTIONAL (#:DEFAULT #:NIL))
  (GETHASH #:KEY HASH-TABLE &OPTIONAL #:DEFAULT)
  (GO #:TAG)
  (GRAPHIC-CHAR-P CHAR)
  (HANDLER-BIND #:BINDINGS &BODY #:FORMS)
  (HANDLER-CASE #:FORM &REST #:CASES)
  (HASH-TABLE-COUNT HASH-TABLE)
  (HASH-TABLE-P #:OBJECT)
  (HASH-TABLE-REHASH-SIZE #:INSTANCE)
  (HASH-TABLE-REHASH-THRESHOLD #:INSTANCE)
  (HASH-TABLE-SIZE HASH-TABLE)
  (HASH-TABLE-TEST #:INSTANCE)
  (HOST-NAMESTRING PATHNAME)
  (IDENTITY #:THING)
  (IF #:TEST #:THEN &OPTIONAL #:ELSE)
  (IGNORE-ERRORS &REST #:FORMS)
  (IMAGPART NUMBER)
  (IMPORT #:SYMBOLS &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (IN-PACKAGE #:STRING-DESIGNATOR)
  (INCF #:PLACE &OPTIONAL (#:DELTA 1) &ENVIRONMENT #:ENV)
  (INITIALIZE-INSTANCE #:GF &KEY (#:LAMBDA-LIST #:NIL #:LAMBDA-LIST-P)
                       #:ARGUMENT-PRECEDENCE-ORDER &ALLOW-OTHER-KEYS)
  (INPUT-STREAM-P STREAM)
  (INSPECT #:OBJECT)
  (INTEGER-DECODE-FLOAT #:X)
  (INTEGER-LENGTH INTEGER)
  (INTEGERP #:OBJECT)
  (INTERACTIVE-STREAM-P STREAM)
  (INTERN #:NAME &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (INTERSECTION #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
                (#:TEST-NOT #:NIL #:NOTP))
  (INVALID-METHOD-ERROR METHOD #:FORMAT-CONTROL &REST #:FORMAT-ARGUMENTS)
  (INVOKE-DEBUGGER CONDITION)
  (INVOKE-RESTART RESTART &REST VALUES)
  (INVOKE-RESTART-INTERACTIVELY RESTART)
  (ISQRT #:N)
  (KEYWORDP #:OBJECT)
  (LABELS #:DEFINITIONS
    &BODY
    #:BODY)
  (LAMBDA &WHOLE #:WHOLE #:ARGS &BODY #:BODY)
  (LAST LIST &OPTIONAL (#:N 1))
  (LCM &REST #:INTEGERS)
  (LDB #:BYTESPEC INTEGER)
  (LDB-TEST #:BYTESPEC INTEGER)
  (LDIFF LIST #:OBJECT)
  (LENGTH SEQUENCE)
  (LET #:BINDINGS
    &BODY
    #:BODY)
  (LET* #:BINDINGS
    &BODY
    #:BODY)
  (LISP-IMPLEMENTATION-TYPE)
  (LISP-IMPLEMENTATION-VERSION)
  (LIST &REST #:ARGS)
  (LIST* #:ARG &REST #:OTHERS)
  (LIST-ALL-PACKAGES)
  (LIST-LENGTH LIST)
  (LISTEN &OPTIONAL (STREAM *STANDARD-INPUT*))
  (LISTP #:OBJECT)
  (LOAD #:PATHSPEC &KEY (#:VERBOSE *LOAD-VERBOSE*) (PRINT *LOAD-PRINT*)
        (#:IF-DOES-NOT-EXIST T) (#:EXTERNAL-FORMAT :DEFAULT))
  (LOAD-LOGICAL-PATHNAME-TRANSLATIONS #:HOST)
  (LOAD-TIME-VALUE #:FORM &OPTIONAL #:READ-ONLY-P)
  (LOCALLY &BODY #:BODY)
  (LOG NUMBER &OPTIONAL (#:BASE #:NIL #:BASE-P))
  (LOGAND &REST #:INTEGERS)
  (LOGANDC1 #:INTEGER1 #:INTEGER2)
  (LOGANDC2 #:INTEGER1 #:INTEGER2)
  (LOGBITP #:INDEX INTEGER)
  (LOGCOUNT INTEGER)
  (LOGEQV &REST #:INTEGERS)
  (LOGICAL-PATHNAME #:PATHSPEC)
  (LOGICAL-PATHNAME-TRANSLATIONS #:HOST)
  (LOGIOR &REST #:INTEGERS)
  (LOGNAND #:INTEGER1 #:INTEGER2)
  (LOGNOR #:INTEGER1 #:INTEGER2)
  (LOGNOT NUMBER)
  (LOGORC1 #:INTEGER1 #:INTEGER2)
  (LOGORC2 #:INTEGER1 #:INTEGER2)
  (LOGTEST #:INTEGER1 #:INTEGER2)
  (LOGXOR &REST #:INTEGERS)
  (LONG-SITE-NAME)
  (LOOP &ENVIRONMENT #:ENV &REST #:KEYWORDS-AND-FORMS)
  (LOOP-FINISH)
  (LOWER-CASE-P CHAR)
  (MACHINE-INSTANCE)
  (MACHINE-TYPE)
  (MACHINE-VERSION)
  (MACRO-FUNCTION SYMBOL &OPTIONAL #:ENV)
  (MACROEXPAND #:FORM &OPTIONAL #:ENV)
  (MACROEXPAND-1 #:FORM &OPTIONAL #:ENV)
  (MACROLET #:DEFINITIONS
    &REST
    #:BODY)
  (MAKE-ARRAY #:DIMENSIONS &KEY (#:ELEMENT-TYPE T)
              (#:INITIAL-ELEMENT #:NIL #:INITIAL-ELEMENT-P)
              (#:INITIAL-CONTENTS #:NIL #:INITIAL-CONTENTS-P) #:ADJUSTABLE
              FILL-POINTER #:DISPLACED-TO #:DISPLACED-INDEX-OFFSET)
  (MAKE-BROADCAST-STREAM &REST #:STREAMS)
  (MAKE-CONCATENATED-STREAM &REST #:STREAMS)
  (MAKE-CONDITION TYPE &REST #:ARGS)
  (MAKE-DISPATCH-MACRO-CHARACTER CHAR &OPTIONAL (#:NON-TERMINATING-P #:NIL)
                                 (#:RT *READTABLE*))
  (MAKE-ECHO-STREAM #:INPUT-STREAM #:OUTPUT-STREAM)
  (MAKE-HASH-TABLE &KEY (#:TEST 'EQL) (#:SIZE #:+MIN-HASH-TABLE-SIZE+)
                   (#:REHASH-SIZE 1.5) (#:REHASH-THRESHOLD 1) (#:WEAKNESS #:NIL)
                   (#:SYNCHRONIZED))
  (MAKE-INSTANCE CLASS &REST #:INITARGS &ALLOW-OTHER-KEYS)
  (MAKE-INSTANCES-OBSOLETE CLASS)
  (MAKE-LIST #:SIZE &KEY #:INITIAL-ELEMENT)
  (MAKE-LOAD-FORM #:OBJECT &OPTIONAL #:ENVIRONMENT)
  (MAKE-LOAD-FORM-SAVING-SLOTS #:OBJECT &KEY (#:SLOT-NAMES #:NIL #:SLOT-NAMES-P)
                               #:ENVIRONMENT)
  (MAKE-PACKAGE #:NAME &KEY (#:USE '#:NIL) #:NICKNAMES (#:INTERNAL-SYMBOLS 10)
                (#:EXTERNAL-SYMBOLS 10))
  (MAKE-PATHNAME &KEY #:HOST (#:DEVICE #:NIL #:DEVP) (DIRECTORY #:NIL #:DIRP)
                 (#:NAME #:NIL #:NAMEP) (TYPE #:NIL TYPEP)
                 (#:VERSION #:NIL #:VERSIONP) #:DEFAULTS (CASE :LOCAL))
  (MAKE-RANDOM-STATE &OPTIONAL #:STATE)
  (MAKE-SEQUENCE TYPE LENGTH &KEY (#:INITIAL-ELEMENT #:NIL #:IEP))
  (MAKE-STRING COUNT &KEY (#:ELEMENT-TYPE 'CHARACTER)
               ((:INITIAL-ELEMENT #:FILL-CHAR)))
  (MAKE-STRING-INPUT-STREAM STRING &OPTIONAL (#:START 0) #:END)
  (MAKE-STRING-OUTPUT-STREAM &KEY (#:ELEMENT-TYPE 'CHARACTER) &AUX
                             (#:BUFFER
                              (MAKE-STRING
                               #:*STRING-OUTPUT-STREAM-BUFFER-INITIAL-SIZE*)))
  (MAKE-SYMBOL STRING)
  (MAKE-SYNONYM-STREAM SYMBOL)
  (MAKE-TWO-WAY-STREAM #:INPUT-STREAM #:OUTPUT-STREAM)
  (MAKUNBOUND SYMBOL)
  (MAP #:RESULT-TYPE FUNCTION #:FIRST-SEQUENCE &REST #:MORE-SEQUENCES)
  (MAP-INTO #:RESULT-SEQUENCE FUNCTION &REST #:SEQUENCES)
  (MAPC FUNCTION LIST &REST #:MORE-LISTS)
  (MAPCAN FUNCTION LIST &REST #:MORE-LISTS)
  (MAPCAR FUNCTION LIST &REST #:MORE-LISTS)
  (MAPCON FUNCTION LIST &REST #:MORE-LISTS)
  (MAPHASH #:FUNCTION-DESIGNATOR HASH-TABLE)
  (MAPL FUNCTION LIST &REST #:MORE-LISTS)
  (MAPLIST FUNCTION LIST &REST #:MORE-LISTS)
  (MASK-FIELD #:BYTESPEC INTEGER)
  (MAX NUMBER &REST #:MORE-NUMBERS)
  (MEMBER #:ITEM LIST &KEY #:KEY (#:TEST #:NIL #:TESTP) (#:TEST-NOT #:NIL #:NOTP))
  (MEMBER-IF #:TEST LIST &KEY #:KEY)
  (MEMBER-IF-NOT #:TEST LIST &KEY #:KEY)
  (MERGE #:RESULT-TYPE #:SEQUENCE1 #:SEQUENCE2 #:PREDICATE &KEY #:KEY)
  (MERGE-PATHNAMES PATHNAME &OPTIONAL (#:DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*)
                   (#:DEFAULT-VERSION :NEWEST))
  (METHOD-COMBINATION-ERROR #:FORMAT-CONTROL &REST #:FORMAT-ARGUMENTS)
  (METHOD-QUALIFIERS #:M)
  (MIN NUMBER &REST #:MORE-NUMBERS)
  (MINUSP NUMBER)
  (MISMATCH #:SEQUENCE1 #:SEQUENCE2 &REST #:ARGS &KEY #:FROM-END (#:TEST #'EQL)
            (#:TEST-NOT #:NIL) (#:START1 0) (#:END1 #:NIL) (#:START2 0)
            (#:END2 #:NIL) (#:KEY #:NIL))
  (MOD NUMBER #:DIVISOR)
  (MUFFLE-WARNING &OPTIONAL CONDITION)
  (MULTIPLE-VALUE-BIND #:VARS #:VALUE-FORM &BODY #:BODY)
  (MULTIPLE-VALUE-CALL #:FUN &REST #:ARGS)
  (MULTIPLE-VALUE-LIST #:VALUE-FORM)
  (MULTIPLE-VALUE-PROG1 #:VALUES-FORM &REST #:FORMS)
  (MULTIPLE-VALUE-SETQ #:VARS #:VALUE-FORM)
  (NAME-CHAR #:NAME)
  (NAMESTRING PATHNAME)
  (NBUTLAST LIST &OPTIONAL (#:N 1))
  (NCONC &REST #:LISTS)
  (NINTERSECTION #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
                 (#:TEST-NOT #:NIL #:NOTP))
  (NINTH LIST)
  (NO-APPLICABLE-METHOD GENERIC-FUNCTION &REST #:ARGS)
  (NO-NEXT-METHOD GENERIC-FUNCTION METHOD &REST #:ARGS)
  (NOT #:OBJECT)
  (NOTANY #:PRED #:FIRST-SEQ &REST #:MORE-SEQS)
  (NOTEVERY #:PRED #:FIRST-SEQ &REST #:MORE-SEQS)
  (NRECONC #:X #:Y)
  (NREVERSE SEQUENCE)
  (NSET-DIFFERENCE #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
                   (#:TEST-NOT #:NIL #:NOTP))
  (NSET-EXCLUSIVE-OR #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
                     (#:TEST-NOT #'EQL #:NOTP))
  (NSTRING-CAPITALIZE STRING &KEY (#:START 0) #:END)
  (NSTRING-DOWNCASE STRING &KEY (#:START 0) #:END)
  (NSTRING-UPCASE STRING &KEY (#:START 0) #:END)
  (NSUBLIS #:ALIST #:TREE &KEY #:KEY (#:TEST #'EQL #:TESTP)
           (#:TEST-NOT #'EQL #:NOTP))
  (NSUBST #:NEW #:OLD #:TREE &KEY #:KEY (#:TEST #'EQL #:TESTP)
          (#:TEST-NOT #'EQL #:NOTP))
  (NSUBST-IF #:NEW #:TEST #:TREE &KEY #:KEY)
  (NSUBST-IF-NOT #:NEW #:TEST #:TREE &KEY #:KEY)
  (NSUBSTITUTE #:NEW #:OLD SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:TEST #'EQL)
               (#:TEST-NOT #:NIL) (#:END #:NIL) (COUNT #:NIL) (#:KEY #:NIL)
               (#:START 0))
  (NSUBSTITUTE-IF #:NEW #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END
                  (#:START 0) (#:END #:NIL) (COUNT #:NIL) (#:KEY #:NIL))
  (NSUBSTITUTE-IF-NOT #:NEW #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END
                      (#:START 0) (#:END #:NIL) (COUNT #:NIL) (#:KEY #:NIL))
  (NTH #:N LIST)
  (NTH-VALUE #:N #:FORM)
  (NTHCDR #:N LIST)
  (NULL #:OBJECT)
  (NUMBERP #:OBJECT)
  (NUMERATOR NUMBER)
  (NUNION #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
          (#:TEST-NOT #:NIL #:NOTP))
  (ODDP NUMBER)
  (OPEN #:FILENAME &KEY (#:DIRECTION :INPUT) (#:ELEMENT-TYPE 'BASE-CHAR)
        (#:IF-EXISTS #:NIL #:IF-EXISTS-GIVEN)
        (#:IF-DOES-NOT-EXIST #:NIL #:IF-DOES-NOT-EXIST-GIVEN)
        (#:EXTERNAL-FORMAT :DEFAULT) &AUX (#:DIRECTION #:DIRECTION)
        (#:IF-DOES-NOT-EXIST #:IF-DOES-NOT-EXIST) (#:IF-EXISTS #:IF-EXISTS))
  (OPEN-STREAM-P STREAM)
  (OR &REST #:FORMS)
  (OUTPUT-STREAM-P STREAM)
  (PACKAGE-ERROR-PACKAGE CONDITION)
  (PACKAGE-NAME #:PACKAGE-DESIGNATOR)
  (PACKAGE-NICKNAMES #:X)
  (PACKAGE-SHADOWING-SYMBOLS #:X)
  (PACKAGE-USE-LIST #:X)
  (PACKAGE-USED-BY-LIST #:X)
  (PACKAGEP #:OBJECT)
  (PAIRLIS #:KEYS #:DATA &OPTIONAL (#:ALIST '#:NIL))
  (PARSE-INTEGER STRING &KEY (#:START 0) #:END (#:RADIX 10) #:JUNK-ALLOWED)
  (PARSE-NAMESTRING #:THING &OPTIONAL #:HOST
                    (#:DEFAULTS *DEFAULT-PATHNAME-DEFAULTS*) &KEY (#:START 0)
                    #:END #:JUNK-ALLOWED)
  (PATHNAME #:PATHSPEC)
  (PATHNAME-DEVICE PATHNAME &KEY (CASE :LOCAL))
  (PATHNAME-DIRECTORY PATHNAME &KEY (CASE :LOCAL))
  (PATHNAME-HOST PATHNAME &KEY (CASE :LOCAL))
  (PATHNAME-MATCH-P #:IN-PATHNAME #:IN-WILDNAME)
  (PATHNAME-NAME PATHNAME &KEY (CASE :LOCAL))
  (PATHNAME-TYPE PATHNAME &KEY (CASE :LOCAL))
  (PATHNAME-VERSION PATHNAME)
  (PATHNAMEP #:OBJECT)
  (PEEK-CHAR &OPTIONAL (#:PEEK-TYPE #:NIL) (STREAM *STANDARD-INPUT*)
             (#:EOF-ERROR-P T) #:EOF-VALUE #:RECURSIVE-P)
  (PHASE NUMBER)
  (PLUSP NUMBER)
  (POP #:PLACE &ENVIRONMENT #:ENV)
  (POSITION #:ITEM SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0) #:END #:KEY
            #:TEST #:TEST-NOT)
  (POSITION-IF #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
               #:END #:KEY)
  (POSITION-IF-NOT #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
                   #:END #:KEY)
  (PPRINT #:OBJECT &OPTIONAL STREAM)
  (PPRINT-DISPATCH #:OBJECT &OPTIONAL (#:TABLE *PRINT-PPRINT-DISPATCH*))
  (PPRINT-EXIT-IF-LIST-EXHAUSTED)
  (PPRINT-FILL STREAM LIST &OPTIONAL (#:COLON? T) #:ATSIGN?)
  (PPRINT-INDENT #:RELATIVE-TO #:N &OPTIONAL STREAM)
  (PPRINT-LINEAR STREAM LIST &OPTIONAL (#:COLON? T) #:ATSIGN?)
  (PPRINT-LOGICAL-BLOCK
      (#:STREAM-SYMBOL #:OBJECT &KEY (#:PREFIX #:NIL #:PREFIXP)
       (#:PER-LINE-PREFIX #:NIL #:PER-LINE-PREFIX-P) (#:SUFFIX "" #:SUFFIXP))
    &BODY
    #:BODY
    &ENVIRONMENT
    #:ENV)
  (PPRINT-NEWLINE #:KIND &OPTIONAL STREAM)
  (PPRINT-POP)
  (PPRINT-TAB #:KIND #:COLNUM #:COLINC &OPTIONAL STREAM)
  (PPRINT-TABULAR STREAM LIST &OPTIONAL (#:COLON? T) #:ATSIGN? #:TABSIZE)
  (PRIN1 #:OBJECT &OPTIONAL STREAM)
  (PRIN1-TO-STRING #:OBJECT)
  (PRINC #:OBJECT &OPTIONAL STREAM)
  (PRINC-TO-STRING #:OBJECT)
  (PRINT #:OBJECT &OPTIONAL STREAM)
  (PRINT-NOT-READABLE-OBJECT CONDITION)
  (PRINT-OBJECT #:OBJECT STREAM)
  (PRINT-UNREADABLE-OBJECT (#:OBJECT STREAM &KEY TYPE IDENTITY) &BODY #:BODY)
  (PROBE-FILE #:PATHSPEC)
  (PROCLAIM #:RAW-FORM)
  (PROG #:VARLIST &BODY #:BODY-DECLS)
  (PROG* #:VARLIST &BODY #:BODY-DECLS)
  (PROG1 #:RESULT &BODY #:BODY)
  (PROG2 #:FORM1 #:RESULT &BODY #:BODY)
  (PROGN &REST #:FORMS)
  (PROGV #:VARS #:VALS &BODY #:BODY)
  (PROVIDE #:MODULE-NAME)
  (PSETF &REST #:ARGS &ENVIRONMENT #:ENV)
  (PSETQ &REST #:PAIRS)
  (PUSH #:OBJ #:PLACE &ENVIRONMENT #:ENV)
  (PUSHNEW #:OBJ #:PLACE &REST #:KEYS &KEY #:KEY #:TEST #:TEST-NOT &ENVIRONMENT
           #:ENV)
  '#:THING
  (RANDOM #:ARG &OPTIONAL (#:STATE *RANDOM-STATE*))
  (RANDOM-STATE-P #:OBJECT)
  (RASSOC #:ITEM #:ALIST &KEY #:KEY (#:TEST #:NIL #:TESTP)
          (#:TEST-NOT #:NIL #:NOTP))
  (RASSOC-IF #:PREDICATE #:ALIST &KEY #:KEY)
  (RASSOC-IF-NOT #:PREDICATE #:ALIST &KEY #:KEY)
  (RATIONAL #:X)
  (RATIONALIZE #:X)
  (RATIONALP #:OBJECT)
  (READ &OPTIONAL (STREAM *STANDARD-INPUT*) (#:EOF-ERROR-P T) (#:EOF-VALUE #:NIL)
        (#:RECURSIVE-P #:NIL))
  (READ-BYTE STREAM &OPTIONAL (#:EOF-ERROR-P T) #:EOF-VALUE)
  (READ-CHAR &OPTIONAL (STREAM *STANDARD-INPUT*) (#:EOF-ERROR-P T) #:EOF-VALUE
             #:RECURSIVE-P)
  (READ-CHAR-NO-HANG &OPTIONAL (STREAM *STANDARD-INPUT*) (#:EOF-ERROR-P T)
                     #:EOF-VALUE #:RECURSIVE-P)
  (READ-DELIMITED-LIST #:ENDCHAR &OPTIONAL (#:INPUT-STREAM *STANDARD-INPUT*)
                       #:RECURSIVE-P)
  (READ-FROM-STRING STRING &OPTIONAL (#:EOF-ERROR-P T) #:EOF-VALUE &KEY
                    (#:START 0) #:END #:PRESERVE-WHITESPACE)
  (READ-LINE &OPTIONAL (STREAM *STANDARD-INPUT*) (#:EOF-ERROR-P T) #:EOF-VALUE
             #:RECURSIVE-P)
  (READ-PRESERVING-WHITESPACE &OPTIONAL (STREAM *STANDARD-INPUT*)
                              (#:EOF-ERROR-P T) (#:EOF-VALUE #:NIL)
                              (#:RECURSIVE-P #:NIL))
  (READ-SEQUENCE #:SEQ STREAM &KEY (#:START 0) #:END)
  (READTABLE-CASE READTABLE)
  (READTABLEP #:OBJECT)
  (REALP #:OBJECT)
  (REALPART NUMBER)
  (REDUCE FUNCTION SEQUENCE &REST #:ARGS &KEY (#:KEY #:NIL) #:FROM-END
          (#:START 0) (#:END #:NIL) (#:INITIAL-VALUE #:NIL #:IVP))
  (REINITIALIZE-INSTANCE #:GF &REST #:ARGS &KEY #:DIRECT-SUPERCLASSES
                         (#:LAMBDA-LIST #:NIL #:LAMBDA-LIST-P)
                         (#:ARGUMENT-PRECEDENCE-ORDER #:NIL #:APO-P)
                         &ALLOW-OTHER-KEYS)
  (REM NUMBER #:DIVISOR)
  (REMF #:PLACE #:INDICATOR &ENVIRONMENT #:ENV)
  (REMHASH #:KEY HASH-TABLE)
  (REMOVE #:ITEM SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:TEST #'EQL)
          (#:TEST-NOT #:NIL) (#:START 0) (#:END #:NIL) (COUNT #:NIL)
          (#:KEY #:NIL))
  (REMOVE-DUPLICATES SEQUENCE &REST #:ARGS &KEY (#:TEST #'EQL) (#:TEST-NOT #:NIL)
                     (#:START 0) (#:END #:NIL) #:FROM-END (#:KEY #:NIL))
  (REMOVE-IF #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
             (#:END #:NIL) (COUNT #:NIL) (#:KEY #:NIL))
  (REMOVE-IF-NOT #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:START 0)
                 (#:END #:NIL) (COUNT #:NIL) (#:KEY #:NIL))
  (REMOVE-METHOD GENERIC-FUNCTION METHOD)
  (REMPROP SYMBOL #:INDICATOR)
  (RENAME-FILE #:FILE #:NEW-NAME)
  (RENAME-PACKAGE PACKAGE #:NAME &OPTIONAL (#:NICKNAMES #:NIL))
  (REPLACE #:SEQUENCE1 #:SEQUENCE2 &REST #:ARGS &KEY (#:START1 0) (#:END1 #:NIL)
           (#:START2 0) (#:END2 #:NIL))
  (REQUIRE #:MODULE-NAME &OPTIONAL #:PATHNAMES)
  (REST LIST)
  (RESTART-BIND #:BINDINGS &BODY #:FORMS)
  (RESTART-CASE #:EXPRESSION &BODY #:CLAUSES &ENVIRONMENT #:ENV)
  (RESTART-NAME #:INSTANCE)
  (RETURN &OPTIONAL (#:VALUE #:NIL))
  (RETURN-FROM #:NAME &OPTIONAL #:VALUE)
  (REVAPPEND #:X #:Y)
  (REVERSE SEQUENCE)
  (ROOM &OPTIONAL (#:VERBOSITY :DEFAULT))
  (ROTATEF &REST #:ARGS &ENVIRONMENT #:ENV)
  (ROUND NUMBER &OPTIONAL (#:DIVISOR 1))
  (ROW-MAJOR-AREF ARRAY #:INDEX)
  (RPLACA CONS #:X)
  (RPLACD CONS #:X)
  (SBIT #:SIMPLE-BIT-ARRAY &REST #:SUBSCRIPTS)
  (SCALE-FLOAT #:F #:EX)
  (SCHAR STRING #:INDEX)
  (SEARCH #:SEQUENCE1 #:SEQUENCE2 &REST #:ARGS &KEY #:FROM-END (#:TEST #'EQL)
          (#:TEST-NOT #:NIL) (#:START1 0) (#:END1 #:NIL) (#:START2 0)
          (#:END2 #:NIL) (#:KEY #:NIL))
  (SECOND LIST)
  (SET SYMBOL #:NEW-VALUE)
  (SET-DIFFERENCE #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
                  (#:TEST-NOT #:NIL #:NOTP))
  (SET-DISPATCH-MACRO-CHARACTER #:DISP-CHAR #:SUB-CHAR FUNCTION &OPTIONAL
                                (#:RT-DESIGNATOR *READTABLE*))
  (SET-EXCLUSIVE-OR #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
                    (#:TEST-NOT #'EQL #:NOTP))
  (SET-MACRO-CHARACTER CHAR FUNCTION &OPTIONAL (#:NON-TERMINATINGP #:NIL)
                       (#:RT-DESIGNATOR *READTABLE*))
  (SET-PPRINT-DISPATCH TYPE FUNCTION &OPTIONAL (#:PRIORITY 0)
                       (#:TABLE *PRINT-PPRINT-DISPATCH*))
  (SET-SYNTAX-FROM-CHAR #:TO-CHAR #:FROM-CHAR &OPTIONAL
                        (#:TO-READTABLE *READTABLE*) (#:FROM-READTABLE #:NIL))
  (SETF &REST #:ARGS &ENVIRONMENT #:ENV)
  (SETQ &WHOLE #:SOURCE &REST #:THINGS)
  (SEVENTH LIST)
  (SHADOW #:SYMBOLS &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (SHADOWING-IMPORT #:SYMBOLS &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (SHARED-INITIALIZE GENERIC-FUNCTION #:SLOT-NAMES &KEY
                     (METHOD-COMBINATION #:NIL #:METHOD-COMBINATION-SUPPLIED-P)
                     (#:METHOD-CLASS #:NIL #:METHOD-CLASS-SUPPLIED-P)
                     DOCUMENTATION #:DECLARATIONS #:ARGUMENT-PRECEDENCE-ORDER
                     (#:LAMBDA-LIST #:NIL #:LAMBDA-LIST-P) (#:NAME #:NIL #:NAMEP)
                     #:SLOT-DEFINITION #:SLOT-NAME #:DEFINITION-SOURCE
                     #:DIRECT-DEFAULT-INITARGS
                     (#:DIRECT-SLOTS #:NIL #:DIRECT-SLOTS-P)
                     (#:DIRECT-SUPERCLASSES #:NIL #:DIRECT-SUPERCLASSES-P)
                     (#:ALLOCATION :INSTANCE) #:ALLOCATION-CLASS #:QUALIFIERS
                     #:SPECIALIZERS FUNCTION ((#:METHOD-CELL #:METHOD-CELL))
                     &ALLOW-OTHER-KEYS)
  (SHIFTF &WHOLE #:FORM &REST #:ARGS &ENVIRONMENT #:ENV)
  (SHORT-SITE-NAME)
  (SIGNAL #:DATUM &REST #:ARGUMENTS)
  (SIGNUM NUMBER)
  (SIMPLE-BIT-VECTOR-P #:OBJECT)
  (SIMPLE-CONDITION-FORMAT-ARGUMENTS CONDITION)
  (SIMPLE-CONDITION-FORMAT-CONTROL CONDITION)
  (SIMPLE-STRING-P #:OBJECT)
  (SIMPLE-VECTOR-P #:OBJECT)
  (SIN NUMBER)
  (SINH NUMBER)
  (SIXTH LIST)
  (SLEEP #:N)
  (SLOT-BOUNDP #:OBJECT #:SLOT-NAME)
  (SLOT-EXISTS-P #:OBJECT #:SLOT-NAME)
  (SLOT-MAKUNBOUND #:OBJECT #:SLOT-NAME)
  (SLOT-MISSING CLASS #:INSTANCE #:SLOT-NAME #:OPERATION &OPTIONAL #:NEW-VALUE)
  (SLOT-UNBOUND CLASS #:INSTANCE #:SLOT-NAME)
  (SLOT-VALUE #:OBJECT #:SLOT-NAME)
  (SOFTWARE-TYPE)
  (SOFTWARE-VERSION)
  (SOME #:PRED #:FIRST-SEQ &REST #:MORE-SEQS)
  (SORT SEQUENCE #:PREDICATE &REST #:ARGS &KEY #:KEY)
  (SPECIAL-OPERATOR-P SYMBOL)
  (SQRT NUMBER)
  (STABLE-SORT SEQUENCE #:PREDICATE &REST #:ARGS &KEY #:KEY)
  (STANDARD-CHAR-P CHAR)
  (STEP #:FORM)
  (STORE-VALUE #:VALUE &OPTIONAL CONDITION)
  (STREAM-ELEMENT-TYPE STREAM)
  (STREAM-ERROR-STREAM CONDITION)
  (STREAM-EXTERNAL-FORMAT STREAM)
  (STREAMP STREAM)
  (STRING #:X)
  (STRING-CAPITALIZE STRING &KEY (#:START 0) #:END)
  (STRING-DOWNCASE STRING &KEY (#:START 0) #:END)
  (STRING-EQUAL #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRING-GREATERP #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0)
                   #:END2)
  (STRING-LEFT-TRIM #:CHAR-BAG STRING)
  (STRING-LESSP #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRING-NOT-EQUAL #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0)
                    #:END2)
  (STRING-NOT-GREATERP #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0)
                       #:END2)
  (STRING-NOT-LESSP #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0)
                    #:END2)
  (STRING-RIGHT-TRIM #:CHAR-BAG STRING)
  (STRING-TRIM #:CHAR-BAG STRING)
  (STRING-UPCASE STRING &KEY (#:START 0) #:END)
  (STRING/= #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRING< #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRING<= #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRING= #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRING> #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRING>= #:STRING1 #:STRING2 &KEY (#:START1 0) #:END1 (#:START2 0) #:END2)
  (STRINGP #:OBJECT)
  (SUBLIS #:ALIST #:TREE &KEY #:KEY (#:TEST #'EQL #:TESTP)
          (#:TEST-NOT #'EQL #:NOTP))
  (SUBSEQ SEQUENCE #:START &OPTIONAL #:END)
  (SUBSETP #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
           (#:TEST-NOT #:NIL #:NOTP))
  (SUBST #:NEW #:OLD #:TREE &KEY #:KEY (#:TEST #'EQL #:TESTP)
         (#:TEST-NOT #'EQL #:NOTP))
  (SUBST-IF #:NEW #:TEST #:TREE &KEY #:KEY)
  (SUBST-IF-NOT #:NEW #:TEST #:TREE &KEY #:KEY)
  (SUBSTITUTE #:NEW #:OLD SEQUENCE &REST #:ARGS &KEY #:FROM-END (#:TEST #'EQL)
              (#:TEST-NOT #:NIL) (#:START 0) (COUNT #:NIL) (#:END #:NIL)
              (#:KEY #:NIL))
  (SUBSTITUTE-IF #:NEW #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END
                 (#:START 0) (#:END #:NIL) (COUNT #:NIL) (#:KEY #:NIL))
  (SUBSTITUTE-IF-NOT #:NEW #:PREDICATE SEQUENCE &REST #:ARGS &KEY #:FROM-END
                     (#:START 0) (#:END #:NIL) (COUNT #:NIL) (#:KEY #:NIL))
  (SUBTYPEP #:TYPE1 #:TYPE2 &OPTIONAL #:ENVIRONMENT)
  (SVREF SIMPLE-VECTOR #:INDEX)
  (SXHASH #:X)
  (SYMBOL-FUNCTION SYMBOL)
  (SYMBOL-MACROLET #:MACROBINDINGS
    &BODY
    #:BODY)
  (SYMBOL-NAME SYMBOL)
  (SYMBOL-PACKAGE SYMBOL)
  (SYMBOL-PLIST SYMBOL)
  (SYMBOL-VALUE SYMBOL)
  (SYMBOLP #:OBJECT)
  (SYNONYM-STREAM-SYMBOL #:INSTANCE)
  (TAGBODY &REST #:STATEMENTS)
  (TAILP #:OBJECT LIST)
  (TAN NUMBER)
  (TANH NUMBER)
  (TENTH LIST)
  (TERPRI &OPTIONAL (STREAM *STANDARD-OUTPUT*))
  (THE #:VALUE-TYPE #:FORM)
  (THIRD LIST)
  (THROW #:TAG #:RESULT)
  (TIME #:FORM)
  (TRACE &REST #:SPECS)
  (TRANSLATE-LOGICAL-PATHNAME PATHNAME &KEY)
  (TRANSLATE-PATHNAME #:SOURCE #:FROM-WILDNAME #:TO-WILDNAME &KEY)
  (TREE-EQUAL #:X #:Y &KEY (#:TEST #'EQL #:TESTP) (#:TEST-NOT #:NIL #:NOTP))
  (TRUENAME #:PATHSPEC)
  (TRUNCATE NUMBER &OPTIONAL (#:DIVISOR 1))
  (TWO-WAY-STREAM-INPUT-STREAM #:INSTANCE)
  (TWO-WAY-STREAM-OUTPUT-STREAM #:INSTANCE)
  (TYPE-ERROR-DATUM CONDITION)
  (TYPE-ERROR-EXPECTED-TYPE CONDITION)
  (TYPE-OF #:OBJECT)
  (TYPECASE #:KEYFORM &BODY #:CASES)
  (TYPEP #:OBJECT TYPE &OPTIONAL #:ENVIRONMENT)
  (UNBOUND-SLOT-INSTANCE CONDITION)
  (UNEXPORT #:SYMBOLS &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (UNINTERN SYMBOL &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (UNION #:LIST1 #:LIST2 &KEY #:KEY (#:TEST #'EQL #:TESTP)
         (#:TEST-NOT #:NIL #:NOTP))
  (UNLESS #:TEST &BODY #:FORMS)
  (UNREAD-CHAR CHARACTER &OPTIONAL (STREAM *STANDARD-INPUT*))
  (UNTRACE &REST #:SPECS)
  (UNUSE-PACKAGE #:PACKAGES-TO-UNUSE &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (UNWIND-PROTECT #:PROTECTED &BODY #:CLEANUP)
  (UPDATE-INSTANCE-FOR-DIFFERENT-CLASS #:PREVIOUS #:CURRENT &REST #:INITARGS)
  (UPDATE-INSTANCE-FOR-REDEFINED-CLASS #:INSTANCE #:ADDED-SLOTS #:DISCARDED-SLOTS
                                       #:PROPERTY-LIST &REST #:INITARGS)
  (UPGRADED-ARRAY-ELEMENT-TYPE #:SPEC &OPTIONAL #:ENVIRONMENT)
  (UPGRADED-COMPLEX-PART-TYPE #:SPEC &OPTIONAL #:ENVIRONMENT)
  (UPPER-CASE-P CHAR)
  (USE-PACKAGE #:PACKAGES-TO-USE &OPTIONAL (PACKAGE (#:SANE-PACKAGE)))
  (USE-VALUE #:VALUE &OPTIONAL CONDITION)
  (USER-HOMEDIR-PATHNAME &OPTIONAL #:HOST)
  (VALUES &REST VALUES)
  (VALUES-LIST LIST)
  (VECTOR &REST #:OBJECTS)
  (VECTOR-POP ARRAY)
  (VECTOR-PUSH #:NEW-EL ARRAY)
  (VECTOR-PUSH-EXTEND #:NEW-ELEMENT VECTOR &OPTIONAL
                      (#:MIN-EXTENSION
                       (LET ((LENGTH (LENGTH VECTOR)))
                         (MIN (1+ LENGTH) (- ARRAY-DIMENSION-LIMIT LENGTH)))))
  (VECTORP #:OBJECT)
  (WARN #:DATUM &REST #:ARGUMENTS)
  (WHEN #:TEST &BODY #:FORMS)
  (WILD-PATHNAME-P PATHNAME &OPTIONAL #:FIELD-KEY)
  (WITH-ACCESSORS #:SLOTS #:INSTANCE &BODY #:BODY)
  (WITH-COMPILATION-UNIT #:OPTIONS &BODY #:BODY)
  (WITH-CONDITION-RESTARTS #:CONDITION-FORM #:RESTARTS-FORM &BODY #:BODY)
  (WITH-HASH-TABLE-ITERATOR (#:NAME HASH-TABLE) &BODY #:BODY)
  (WITH-INPUT-FROM-STRING (#:VAR STRING &KEY #:INDEX #:START #:END)
    &BODY
    #:FORMS-DECLS)
  (WITH-OPEN-FILE (STREAM #:FILESPEC &REST #:OPTIONS) &BODY #:BODY)
  (WITH-OPEN-STREAM (#:VAR STREAM) &BODY #:FORMS-DECLS)
  (WITH-OUTPUT-TO-STRING
      (#:VAR &OPTIONAL STRING &KEY (#:ELEMENT-TYPE ''CHARACTER))
    &BODY
    #:FORMS-DECLS)
  (WITH-PACKAGE-ITERATOR (#:MNAME #:PACKAGE-LIST &REST #:SYMBOL-TYPES)
    &BODY
    #:BODY)
  (WITH-SIMPLE-RESTART (RESTART-NAME #:FORMAT-STRING &REST #:FORMAT-ARGUMENTS)
    &BODY
    #:FORMS)
  (WITH-SLOTS #:SLOTS #:INSTANCE &BODY #:BODY)
  (WITH-STANDARD-IO-SYNTAX &BODY #:BODY)
  (WRITE #:OBJECT &KEY ((:STREAM STREAM) *STANDARD-OUTPUT*)
         ((:ESCAPE *PRINT-ESCAPE*) *PRINT-ESCAPE*)
         ((:RADIX *PRINT-RADIX*) *PRINT-RADIX*)
         ((:BASE *PRINT-BASE*) *PRINT-BASE*)
         ((:CIRCLE *PRINT-CIRCLE*) *PRINT-CIRCLE*)
         ((:PRETTY *PRINT-PRETTY*) *PRINT-PRETTY*)
         ((:LEVEL *PRINT-LEVEL*) *PRINT-LEVEL*)
         ((:LENGTH *PRINT-LENGTH*) *PRINT-LENGTH*)
         ((:CASE *PRINT-CASE*) *PRINT-CASE*)
         ((:ARRAY *PRINT-ARRAY*) *PRINT-ARRAY*)
         ((:GENSYM *PRINT-GENSYM*) *PRINT-GENSYM*)
         ((:READABLY *PRINT-READABLY*) *PRINT-READABLY*)
         ((:RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) *PRINT-RIGHT-MARGIN*)
         ((:MISER-WIDTH *PRINT-MISER-WIDTH*) *PRINT-MISER-WIDTH*)
         ((:LINES *PRINT-LINES*) *PRINT-LINES*)
         ((:PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*) *PRINT-PPRINT-DISPATCH*))
  (WRITE-BYTE INTEGER STREAM)
  (WRITE-CHAR CHARACTER &OPTIONAL (STREAM *STANDARD-OUTPUT*))
  (WRITE-LINE STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (#:START 0) #:END)
  (WRITE-SEQUENCE #:SEQ STREAM &KEY (#:START 0) (#:END #:NIL))
  (WRITE-STRING STRING &OPTIONAL (STREAM *STANDARD-OUTPUT*) &KEY (#:START 0)
                #:END)
  (WRITE-TO-STRING #:OBJECT &KEY ((:ESCAPE *PRINT-ESCAPE*) *PRINT-ESCAPE*)
                   ((:RADIX *PRINT-RADIX*) *PRINT-RADIX*)
                   ((:BASE *PRINT-BASE*) *PRINT-BASE*)
                   ((:CIRCLE *PRINT-CIRCLE*) *PRINT-CIRCLE*)
                   ((:PRETTY *PRINT-PRETTY*) *PRINT-PRETTY*)
                   ((:LEVEL *PRINT-LEVEL*) *PRINT-LEVEL*)
                   ((:LENGTH *PRINT-LENGTH*) *PRINT-LENGTH*)
                   ((:CASE *PRINT-CASE*) *PRINT-CASE*)
                   ((:ARRAY *PRINT-ARRAY*) *PRINT-ARRAY*)
                   ((:GENSYM *PRINT-GENSYM*) *PRINT-GENSYM*)
                   ((:READABLY *PRINT-READABLY*) *PRINT-READABLY*)
                   ((:RIGHT-MARGIN *PRINT-RIGHT-MARGIN*) *PRINT-RIGHT-MARGIN*)
                   ((:MISER-WIDTH *PRINT-MISER-WIDTH*) *PRINT-MISER-WIDTH*)
                   ((:LINES *PRINT-LINES*) *PRINT-LINES*)
                   ((:PPRINT-DISPATCH *PRINT-PPRINT-DISPATCH*)
                    *PRINT-PPRINT-DISPATCH*))
  (Y-OR-N-P &OPTIONAL #:FORMAT-STRING &REST #:ARGUMENTS)
  (YES-OR-NO-P &OPTIONAL #:FORMAT-STRING &REST #:ARGUMENTS)
  (ZEROP NUMBER)
))

(in-package :clisp-arglist)
(defvar *arglist-map* nil)
(unless *arglist-map*
  (setf *arglist-map* (make-hash-table)))

(defun load-arglist ()
  (dolist (i *arglist-list*)
    (setf (gethash (car i) *arglist-map*) (cdr i))))

(defun arglist (function)
  (multiple-value-bind (v p)
      (gethash function *arglist-map*)
    (if p
        v
        (ext:arglist function))))

(load-arglist)

(in-package :swank-backend)

(defimplementation arglist (fname)
  (block nil
    (or (ignore-errors
          (let ((exp (function-lambda-expression fname)))
            (and exp (return (second exp)))))
        (ignore-errors
          (gethash fname clisp-arglist:*arglist-map*))
        (ignore-errors
          (return (ext:arglist fname)))
        :not-available)))