;;; Loading #P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/doit.lsp"

;;; Loading #P"c:/cygwin/home/Jjgarcia/tmp/ecl.ucd/cmp.fas"

;;; Loading #P"c:/cygwin/home/Jjgarcia/tmp/ecl.ucd/sysfun.lsp"

;;; Loading "C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/gclload1.lsp"

;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0

;;; End of Pass 1.

;;; Note: Invoking external command:

;;;   cl -I"c:/cygwin/home/Jjgarcia/tmp/ecl.ucd/"  /EHsc /DGC_DLL /DGC_BUILD /nologo /D_CRT_SECURE_NO_DEPRECATE /DNDEBUG /MD /O2  /O2 -w -c "C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFEFF.c" -Fo"C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFEFF.obj"EFEFF.c


;;; Note: Invoking external command:

;;;   cl -Fe"C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFEFF.fas" "C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFEFF.obj"   /LD /link /incremental:no /nologo /nodefaultlib:libcmt /nodefaultlib:libcmtd /nodefaultlib:libc /nodefaultlib:libcd /nodefaultlib:msvcrtd.lib ecl.lib user32.lib ws2_32.lib shell32.lib /EXPORT:init_fas_CODE /LIBPATH:c:/cygwin/home/Jjgarcia/tmp/ecl.ucd/ /IMPLIB:C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFEFF.implib   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFEFF.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFEFF.exp


;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/rt.lsp.

;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0

;;; Compiling (DEFVAR *TEST* ...).

;;; Compiling (DEFVAR *DO-TESTS-WHEN-DEFINED* ...).

;;; Compiling (DEFVAR *ENTRIES* ...).

;;; Compiling (DEFVAR *ENTRIES-TAIL* ...).

;;; Compiling (DEFVAR *ENTRIES-TABLE* ...).

;;; Compiling (DEFVAR *IN-TEST* ...).

;;; Compiling (DEFVAR *DEBUG* ...).

;;; Compiling (DEFVAR *CATCH-ERRORS* ...).

;;; Compiling (DEFVAR *PRINT-CIRCLE-ON-FAILURE* ...).

;;; Compiling (DEFVAR *COMPILE-TESTS* ...).

;;; Compiling (DEFVAR *EXPANDED-EVAL* ...).

;;; Compiling (DEFVAR *OPTIMIZATION-SETTINGS* ...).

;;; Compiling (DEFVAR *FAILED-TESTS* ...).

;;; Compiling (DEFVAR *PASSED-TESTS* ...).

;;; Compiling (DEFVAR *EXPECTED-FAILURES* ...).

;;; Compiling (DEFVAR *NOTES* ...).

;;; Compiling (DEFUN MAKE-ENTRY ...).

;;; Compiling (DEFUN MAKE-NOTE ...).

;;; Compiling (DEFMACRO DEFN ...).

;;; Compiling (DEFUN ENTRY-NOTES ...).

;;; Compiling (DEFUN HAS-DISABLED-NOTE ...).

;;; Compiling (DEFUN HAS-NOTE ...).

;;; Compiling (DEFUN PENDING-TESTS ...).

;;; Compiling (DEFUN REM-ALL-TESTS ...).

;;; Compiling (DEFUN REM-TEST ...).

;;; Compiling (DEFUN GET-TEST ...).

;;; Compiling (DEFUN GET-ENTRY ...).

;;; Compiling (DEFMACRO DEFTEST ...).

;;; Compiling (DEFUN ADD-ENTRY ...).

;;; Compiling (DEFUN REPORT-ERROR ...).

;;; Compiling (DEFUN DO-TEST ...).

;;; Compiling (DEFUN MY-AREF ...).

;;; Compiling (DEFUN MY-ROW-MAJOR-AREF ...).

;;; Compiling (DEFUN EQUALP-WITH-CASE ...).

;;; Compiling (DEFUN DO-ENTRY ...).

;;; Compiling (DEFUN EXPANDED-EVAL ...).

;;; Compiling (DEFUN CONTINUE-TESTING ...).

;;; Compiling (DEFUN DO-TESTS ...).

;;; Compiling (DEFUN DO-ENTRIES ...).

;;; Compiling (DEFMACRO DEFNOTE ...).

;;; Compiling (DEFUN DISABLE-NOTE ...).

;;; Compiling (DEFUN ENABLE-NOTE ...).

;;; Compiling (DEFUN DO-EXTENDED-TESTS ...).

;;; End of Pass 1.

;;; Emitting code for MAKE-ENTRY.

;;; Emitting code for MAKE-NOTE.

;;; Emitting code for DEFN.

;;; Emitting code for ENTRY-NOTES.

;;; Emitting code for HAS-DISABLED-NOTE.

;;; Emitting code for HAS-NOTE.

;;; Emitting code for PENDING-TESTS.

;;; Emitting code for REM-ALL-TESTS.

;;; Emitting code for REM-TEST.

;;; Emitting code for GET-TEST.

;;; Emitting code for GET-ENTRY.

;;; Emitting code for DEFTEST.

;;; Emitting code for ADD-ENTRY.

;;; Emitting code for REPORT-ERROR.

;;; Emitting code for DO-TEST.

;;; Emitting code for %PARSE-KEY-ARGS.

;;; Emitting code for MY-AREF.

;;; Emitting code for MY-ROW-MAJOR-AREF.

;;; Emitting code for EQUALP-WITH-CASE.

;;; Emitting code for DO-ENTRY.

;;; Emitting code for %DO.

;;; Emitting code for #:G67.

;;; Emitting code for #:G77.

;;; Emitting code for EXPANDED-EVAL.

;;; Emitting code for CONTINUE-TESTING.

;;; Emitting code for DO-TESTS.

;;; Emitting code for DO-ENTRIES.

;;; Emitting code for DEFNOTE.

;;; Emitting code for DISABLE-NOTE.

;;; Emitting code for ENABLE-NOTE.

;;; Emitting code for DO-EXTENDED-TESTS.

rt.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/rt.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/rt.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/rt.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/rt.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux-macros.lsp.

;;; OPTIMIZE levels: Safety=2, Space=0, Speed=3, Debug=0

;;; Compiling (DEFMACRO HANDLER-CASE ...).

;;; Compiling (DEFMACRO HANDLER-BIND ...).

;;; Compiling (DEFVAR *SHOULD-ALWAYS-BE-TRUE* ...).

;;; Compiling (DEFUN SHOULD-NEVER-BE-CALLED ...).

;;; Compiling (DEFMACRO NORMALLY ...).

;;; Compiling (DEFPARAMETER *REPORT-AND-IGNORE-ERRORS-BREAK* ...).

;;; Compiling (DEFMACRO REPORT-AND-IGNORE-ERRORS ...).

;;; End of Pass 1.

;;; Emitting code for HANDLER-CASE.

;;; Emitting code for HANDLER-BIND.

;;; Emitting code for SHOULD-NEVER-BE-CALLED.

;;; Emitting code for NORMALLY.

;;; Emitting code for REPORT-AND-IGNORE-ERRORS.

ansi-aux-macros.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux-macros.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux-macros.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux-macros.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux-macros.fas" NIL NIL) EFF06.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF06.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF06.exp
EFF09.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF09.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF09.exp


;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/random-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFVAR *MAXIMUM-RANDOM-INT-BITS* ...).

;;; Compiling (DEFUN RANDOM-FROM-SEQ ...).

;;; Compiling (DEFMACRO RANDOM-CASE ...).

;;; Compiling (DEFMACRO RCASE ...).

;;; Compiling (DEFMACRO RSELECT ...).

;;; Compiling (DEFUN MAKE-RANDOM-INTEGER-RANGE ...).

;;; Compiling (DEFUN RANDOM-NONNEGATIVE-REAL ...).

;;; Compiling (DEFUN MAKE-RANDOM-INTEGER ...).

;;; Compiling (DEFUN MAKE-RANDOM-RATIONAL ...).

;;; Compiling (DEFUN MAKE-RANDOM-NONNEGATIVE-RATIONAL ...).

;;; Compiling (DEFUN MAKE-RANDOM-POSITIVE-RATIONAL ...).

;;; Compiling (DEFUN MAKE-RANDOM-BOUNDED-RATIONAL ...).

;;; Compiling (DEFUN MAKE-RANDOM-FLOAT ...).

;;; Compiling (DEFUN MAKE-RANDOM-SYMBOL ...).

;;; Compiling (DEFUN RANDOM-REAL ...).

;;; Compiling (DEFUN RANDOM-FIXNUM ...).

;;; Compiling (DEFUN RANDOM-THING ...).

;;; Compiling (DEFPARAMETER *USE-RANDOM-BYTE* ...).

;;; Compiling (DEFPARAMETER *RANDOM-READABLE* ...).

;;; Compiling (DEFUN MAKE-RANDOM-STRING ...).

;;; Compiling (DEFUN RANDOM-LEAF ...).

;;; Compiling (DEFUN RANDOM-FROM-INTERVAL ...).

;;; Compiling (DEFUN COIN ...).

;;; Compiling (DEFUN RANDOM-PERMUTE ...).

;;; Compiling (DEFUN BINOMIAL-DISTRIBUTION-TEST ...).

;;; Compiling (DEFUN RANDOM-PARTITION* ...).

;;; Compiling (DEFUN RANDOM-PARTITION ...).

;;; Compiling (DEFUN POSITIVE-INTEGER-QUALIFIER-P ...).

;;; Variable RANDOMIZED was undefined. Compiler assumes it is a global.

;;; End of Pass 1.

;;; Emitting code for RANDOM-FROM-SEQ.

;;; Emitting code for #:G6.

;;; Emitting code for #:G7.

;;; Emitting code for RANDOM-CASE.

;;; Emitting code for #:G33.

;;; Emitting code for #:G34.

;;; Emitting code for RCASE.

;;; Emitting code for #:G87.

;;; Emitting code for #:G88.

;;; Emitting code for #:G108.

;;; Emitting code for #:G109.

;;; Emitting code for RSELECT.

;;; Emitting code for #:G140.

;;; Emitting code for #:G141.

;;; Emitting code for MAKE-RANDOM-INTEGER-RANGE.

;;; Emitting code for %R.

;;; Emitting code for RANDOM-NONNEGATIVE-REAL.

;;; Emitting code for MAKE-RANDOM-INTEGER.

;;; Emitting code for MAKE-RANDOM-RATIONAL.

;;; Emitting code for #:G158.

;;; Emitting code for #:G159.

;;; Emitting code for MAKE-RANDOM-NONNEGATIVE-RATIONAL.

;;; Emitting code for #:G167.

;;; Emitting code for #:G168.

;;; Emitting code for MAKE-RANDOM-POSITIVE-RATIONAL.

;;; Emitting code for #:G176.

;;; Emitting code for #:G177.

;;; Emitting code for MAKE-RANDOM-BOUNDED-RATIONAL.

;;; Emitting code for #:G185.

;;; Emitting code for #:G186.

;;; Emitting code for #:G193.

;;; Emitting code for #:G194.

;;; Emitting code for #:G201.

;;; Emitting code for #:G202.

;;; Emitting code for MAKE-RANDOM-FLOAT.

;;; Emitting code for MAKE-RANDOM-SYMBOL.

;;; Emitting code for RANDOM-REAL.

;;; Emitting code for RANDOM-FIXNUM.

;;; Emitting code for RANDOM-THING.

;;; Emitting code for MAKE-RANDOM-STRING.

;;; Emitting code for RANDOM-LEAF.

;;; Emitting code for RANDOM-FROM-INTERVAL.

;;; Emitting code for COIN.

;;; Emitting code for RANDOM-PERMUTE.

;;; Emitting code for BINOMIAL-DISTRIBUTION-TEST.

;;; Emitting code for RANDOM-PARTITION*.

;;; Emitting code for #:G266.

;;; Emitting code for #:G267.

;;; Emitting code for RANDOM-PARTITION.

;;; Emitting code for POSITIVE-INTEGER-QUALIFIER-P.

;;; Emitting code for #:G273.

;;; Emitting code for #:G287.

;;; Emitting code for #:G288.

random-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/random-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/random-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/random-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/random-aux.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN NOTNOT ...).

;;; Compiling (DEFMACRO NOTNOT-MV ...).

;;; Compiling (DEFUN NOTNOT-MV-FN ...).

;;; Compiling (DEFMACRO NOT-MV ...).

;;; Compiling (DEFUN NOT-MV-FN ...).

;;; Compiling (DEFUN TO-FUNCTION ...).

;;; Compiling (DEFMACRO CHECK-VALUES ...).

;;; Compiling (DEFUN CHECK-VALUES-LENGTH ...).

;;; Compiling (DEFMACRO MULTIPLE-VALUE-BIND* ...).

;;; Compiling (DEFUN EQT ...).

;;; Compiling (DEFUN EQLT ...).

;;; Compiling (DEFUN EQUALT ...).

;;; Compiling (DEFUN EQUALPT ...).

;;; Compiling (DEFUN EQUALPT-OR-REPORT ...).

;;; Compiling (DEFUN STRING=T ...).

;;; Compiling (DEFUN =T ...).

;;; Compiling (DEFUN <=T ...).

;;; Compiling (DEFUN MAKE-INT-LIST ...).

;;; Compiling (DEFUN MAKE-INT-ARRAY ...).

;;; Compiling (DEFUN EQUAL-ARRAY ...).

;;; Compiling (DEFUN EMPIRICAL-SUBTYPEP ...).

;;; Compiling (DEFUN CHECK-TYPE-PREDICATE ...).

;;; Compiling (DEFUN CHECK-PREDICATE ...).

;;; Compiling (DEFUN CATCH-CONTINUE-DEBUGGER-HOOK ...).

;;; Compiling (DEFMACRO CATCH-TYPE-ERROR ...).

;;; Compiling (DEFMACRO CLASSIFY-ERROR* ...).

;;; Compiling (DEFUN CLASSIFY-ERROR** ...).

;;; Compiling (DEFMACRO CLASSIFY-ERROR ...).

;;; Compiling (DEFMACRO SIGNALS-ERROR ...).

;;; Compiling (DEFMACRO SIGNALS-ERROR-ALWAYS ...).

;;; Compiling (DEFMACRO SIGNALS-TYPE-ERROR ...).

;;; Compiling (DEFUN CHECK-TYPE-ERROR* ...).

;;; Compiling (DEFMACRO CHECK-TYPE-ERROR ...).

;;; Compiling (DEFUN PRINTABLE-P ...).

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.

;;; Compiling (DEFUN SUBTYPEP* ...).

;;; Compiling (DEFUN SUBTYPEP*-OR-FAIL ...).

;;; Compiling (DEFUN SUBTYPEP*-NOT-OR-FAIL ...).

;;; Compiling (DEFUN COMPOSE ...).

;;; Compiling (DEFUN EVENDIGITP ...).

;;; Compiling (DEFUN ODDDIGITP ...).

;;; Compiling (DEFUN NEXTDIGIT ...).

;;; Compiling (DEFUN IS-EQ-P ...).

;;; Compiling (DEFUN IS-NOT-EQ-P ...).

;;; Compiling (DEFUN IS-EQL-P ...).

;;; Compiling (DEFUN IS-NOT-EQL-P ...).

;;; Compiling (DEFUN ONEP ...).

;;; Compiling (DEFUN CHAR-INVERTCASE ...).

;;; Compiling (DEFUN STRING-INVERTCASE ...).

;;; Compiling (DEFUN SYMBOL< ...).

;;; Compiling (DEFUN MAKE-LIST-EXPR ...).

;;; Compiling (DEFPARAMETER +STANDARD-CHARS+ ...).

;;; Compiling (DEFPARAMETER +BASE-CHARS+ ...).

;;; Compiling (DEFPARAMETER +NUM-BASE-CHARS+ ...).

;;; Compiling (DEFPARAMETER +ALPHA-CHARS+ ...).

;;; Compiling (DEFPARAMETER +LOWER-CASE-CHARS+ ...).

;;; Compiling (DEFPARAMETER +UPPER-CASE-CHARS+ ...).

;;; Compiling (DEFPARAMETER +ALPHANUMERIC-CHARS+ ...).

;;; Compiling (DEFPARAMETER +DIGIT-CHARS+ ...).

;;; Compiling (DEFPARAMETER +EXTENDED-DIGIT-CHARS+ ...).

;;; Compiling (DEFPARAMETER +CODE-CHARS+ ...).

;;; Compiling (DEFPARAMETER +REV-CODE-CHARS+ ...).

;;; Compiling (DEFUN HAS-NON-ABORT-RESTART ...).

;;; Compiling (DEFMACRO HANDLE-NON-ABORT-RESTART ...).

;;; Compiling (DEFUN ELT-V-6-BODY ...).

;;; Compiling (DEFUN MAKE-ADJ-ARRAY ...).

;;; Compiling (DEFUN ELT-ADJ-ARRAY-6-BODY ...).

;;; Compiling (DEFPARAMETER *DISPLACED* ...).

;;; Compiling (DEFUN MAKE-DISPLACED-ARRAY ...).

;;; Compiling (DEFUN ARRAY-UNSIGNED-BYTE-FILL-TEST-FN ...).

;;; Compiling (DEFUN ARRAY-STRING-FILL-TEST-FN ...).

;;; Compiling (DEFPARAMETER +FLOAT-TYPES+ ...).

;;; Compiling (DEFPARAMETER *SUBTYPE-TABLE* ...).

;;; Compiling (DEFPARAMETER *DISJOINT-TYPES-LIST* ...).

;;; Compiling (DEFPARAMETER *DISJOINT-TYPES-LIST2* ...).

;;; Compiling (DEFPARAMETER *TYPES-LIST3* ...).

;;; Compiling (DEFUN TRIM-LIST ...).

;;; Compiling (DEFUN IS-T-OR-NIL ...).

;;; Compiling (DEFUN IS-BUILTIN-CLASS ...).

;;; Compiling (DEFUN EVEN-SIZE-P ...).

;;; Compiling (DEFUN SAFE-ELT ...).

;;; Compiling (DEFMACRO DEFSTRUCT* ...).

;;; Compiling (DEFUN SAFELY-DELETE-PACKAGE ...).

;;; Compiling (DEFUN DELETE-ALL-VERSIONS ...).

;;; Compiling (DEFUN FROB-SIMPLE-CONDITION ...).

;;; Compiling (DEFUN FROB-SIMPLE-ERROR ...).

;;; Compiling (DEFUN FROB-SIMPLE-WARNING ...).

;;; Compiling (DEFPARAMETER *ARRAY-ELEMENT-TYPES* ...).

;;; Compiling (DEFUN COLLECT-PROPERTIES ...).

;;; Compiling (DEFMACRO DEF-MACRO-TEST ...).

;;; Compiling (DEFUN TYPEP* ...).

;;; Compiling (DEFUN APPLYF ...).

;;; Compiling (DEFUN SLOT-BOUNDP* ...).

;;; Compiling (DEFUN SLOT-EXISTS-P* ...).

;;; Compiling (DEFUN MAP-SLOT-BOUNDP* ...).

;;; Compiling (DEFUN MAP-SLOT-EXISTS-P* ...).

;;; Compiling (DEFUN MAP-SLOT-VALUE ...).

;;; Compiling (DEFUN MAP-TYPEP* ...).

;;; Compiling (DEFUN SLOT-VALUE-OR-NIL ...).

;;; Compiling (DEFUN IS-NONCONTIGUOUS-SUBLIST-OF ...).

;;; Compiling (DEFMACRO DEFHARMLESS ...).

;;; Compiling (DEFUN RATIONAL-SAFELY ...).

;;; Compiling (DEFUN IS-SIMILAR ...).

;;; Compiling (DEFGENERIC IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFMETHOD IS-SIMILAR* ...).

;;; Compiling (DEFPARAMETER *INITIAL-PRINT-PPRINT-DISPATCH* ...).

;;; Compiling (DEFMACRO MY-WITH-STANDARD-IO-SYNTAX ...).

;;; Compiling (DEFUN MAKE-SPECIAL-STRING ...).

;;; Compiling (DEFMACRO DO-SPECIAL-STRINGS ...).

;;; Compiling (DEFUN MAKE-SPECIAL-INTEGER-VECTOR ...).

;;; Compiling (DEFMACRO DO-SPECIAL-INTEGER-VECTORS ...).

;;; Compiling (DEFUN STRING-DESIGNATOR-P ...).

;;; Compiling (DEFUN APPROX= ...).

;;; Compiling (DEFUN EPSILON ...).

;;; Compiling (DEFUN NEGATIVE-EPSILON ...).

;;; Compiling (DEFUN SEQUENCEP ...).

;;; Compiling (DEFUN TYPEF ...).

;;; Compiling (DEFUN PACKAGE-DESIGNATOR-P ...).

;;; Compiling (DEFMACRO DEF-FOLD-TEST ...).

;;; Compiling (DEFMACRO EXPAND-IN-CURRENT-ENV ...).

;;; End of Pass 1.

;;; Emitting code for NOTNOT.

;;; Emitting code for NOTNOT-MV.

;;; Emitting code for NOTNOT-MV-FN.

;;; Emitting code for NOT-MV.

;;; Emitting code for NOT-MV-FN.

;;; Emitting code for TO-FUNCTION.

;;; Emitting code for CHECK-VALUES.

;;; Emitting code for CHECK-VALUES-LENGTH.

;;; Emitting code for MULTIPLE-VALUE-BIND*.

;;; Emitting code for EQT.

;;; Emitting code for EQLT.

;;; Emitting code for EQUALT.

;;; Emitting code for EQUALPT.

;;; Emitting code for EQUALPT-OR-REPORT.

;;; Emitting code for STRING=T.

;;; Emitting code for =T.

;;; Emitting code for <=T.

;;; Emitting code for MAKE-INT-LIST.

;;; Emitting code for MAKE-INT-ARRAY.

;;; Emitting code for #:G73.

;;; Emitting code for #:G74.

;;; Emitting code for EQUAL-ARRAY.

;;; Emitting code for EMPIRICAL-SUBTYPEP.

;;; Emitting code for CHECK-TYPE-PREDICATE.

;;; Emitting code for #:G91.

;;; Emitting code for #:G92.

;;; Emitting code for #:G100.

;;; Emitting code for #:G101.

;;; Emitting code for #:G112.

;;; Emitting code for #:G119.

;;; Emitting code for CHECK-PREDICATE.

;;; Emitting code for #:G120.

;;; Emitting code for CATCH-CONTINUE-DEBUGGER-HOOK.

;;; Emitting code for CATCH-TYPE-ERROR.

;;; Emitting code for CLASSIFY-ERROR*.

;;; Emitting code for CLASSIFY-ERROR**.

;;; Emitting code for #:G127.

;;; Emitting code for #:G162.

;;; Emitting code for #:G163.

;;; Emitting code for #:G164.

;;; Emitting code for #:G165.

;;; Emitting code for #:G166.

;;; Emitting code for #:G167.

;;; Emitting code for #:G168.

;;; Emitting code for #:G169.

;;; Emitting code for #:G170.

;;; Emitting code for #:G171.

;;; Emitting code for #:G172.

;;; Emitting code for #:G173.

;;; Emitting code for #:G174.

;;; Emitting code for #:G175.

;;; Emitting code for #:G176.

;;; Emitting code for CLASSIFY-ERROR.

;;; Emitting code for SIGNALS-ERROR.

;;; Emitting code for SIGNALS-ERROR-ALWAYS.

;;; Emitting code for SIGNALS-TYPE-ERROR.

;;; Emitting code for CHECK-TYPE-ERROR*.

;;; Emitting code for #:G202.

;;; Emitting code for #:G209.

;;; Emitting code for CHECK-TYPE-ERROR.

;;; Emitting code for PRINTABLE-P.

;;; Emitting code for #:G221.

;;; Emitting code for SUBTYPEP*.

;;; Emitting code for SUBTYPEP*-OR-FAIL.

;;; Emitting code for SUBTYPEP*-NOT-OR-FAIL.

;;; Emitting code for COMPOSE.

;;; Emitting code for #:G234.

;;; Emitting code for EVENDIGITP.

;;; Emitting code for ODDDIGITP.

;;; Emitting code for NEXTDIGIT.

;;; Emitting code for IS-EQ-P.

;;; Emitting code for #:G238.

;;; Emitting code for IS-NOT-EQ-P.

;;; Emitting code for #:G239.

;;; Emitting code for IS-EQL-P.

;;; Emitting code for #:G240.

;;; Emitting code for IS-NOT-EQL-P.

;;; Emitting code for #:G241.

;;; Emitting code for ONEP.

;;; Emitting code for CHAR-INVERTCASE.

;;; Emitting code for STRING-INVERTCASE.

;;; Emitting code for SYMBOL<.

;;; Emitting code for MAKE-LIST-EXPR.

;;; Emitting code for HAS-NON-ABORT-RESTART.

;;; Emitting code for HANDLE-NON-ABORT-RESTART.

;;; Emitting code for ELT-V-6-BODY.

;;; Emitting code for MAKE-ADJ-ARRAY.

;;; Emitting code for ELT-ADJ-ARRAY-6-BODY.

;;; Emitting code for MAKE-DISPLACED-ARRAY.

;;; Emitting code for ARRAY-UNSIGNED-BYTE-FILL-TEST-FN.

;;; Emitting code for ARRAY-STRING-FILL-TEST-FN.

;;; Emitting code for TRIM-LIST.

;;; Emitting code for IS-T-OR-NIL.

;;; Emitting code for IS-BUILTIN-CLASS.

;;; Emitting code for EVEN-SIZE-P.

;;; Emitting code for SAFE-ELT.

;;; Emitting code for #:G286.

;;; Emitting code for #:G287.

;;; Emitting code for #:G288.

;;; Emitting code for #:G289.

;;; Emitting code for #:G290.

;;; Emitting code for #:G291.

;;; Emitting code for #:G292.

;;; Emitting code for #:G293.

;;; Emitting code for #:G294.

;;; Emitting code for #:G295.

;;; Emitting code for #:G296.

;;; Emitting code for #:G297.

;;; Emitting code for #:G298.

;;; Emitting code for #:G299.

;;; Emitting code for #:G300.

;;; Emitting code for DEFSTRUCT*.

;;; Emitting code for SAFELY-DELETE-PACKAGE.

;;; Emitting code for DELETE-ALL-VERSIONS.

;;; Emitting code for FROB-SIMPLE-CONDITION.

;;; Emitting code for FROB-SIMPLE-ERROR.

;;; Emitting code for FROB-SIMPLE-WARNING.

;;; Emitting code for COLLECT-PROPERTIES.

;;; Emitting code for DEF-MACRO-TEST.

;;; Emitting code for #:G334.

;;; Emitting code for #:G335.

;;; Emitting code for TYPEP*.

;;; Emitting code for APPLYF.

;;; Emitting code for #:G339.

;;; Emitting code for #:G340.

;;; Emitting code for SLOT-BOUNDP*.

;;; Emitting code for SLOT-EXISTS-P*.

;;; Emitting code for MAP-SLOT-BOUNDP*.

;;; Emitting code for MAP-SLOT-EXISTS-P*.

;;; Emitting code for MAP-SLOT-VALUE.

;;; Emitting code for MAP-TYPEP*.

;;; Emitting code for SLOT-VALUE-OR-NIL.

;;; Emitting code for IS-NONCONTIGUOUS-SUBLIST-OF.

;;; Emitting code for DEFHARMLESS.

;;; Emitting code for RATIONAL-SAFELY.

;;; Emitting code for #:G369.

;;; Emitting code for #:G370.

;;; Emitting code for IS-SIMILAR.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for IS-SIMILAR*.

;;; Emitting code for MY-WITH-STANDARD-IO-SYNTAX.

;;; Emitting code for MAKE-SPECIAL-STRING.

;;; Emitting code for DO-SPECIAL-STRINGS.

;;; Emitting code for MAKE-SPECIAL-INTEGER-VECTOR.

;;; Emitting code for DO-SPECIAL-INTEGER-VECTORS.

;;; Emitting code for STRING-DESIGNATOR-P.

;;; Emitting code for #:G428.

;;; Emitting code for APPROX=.

;;; Emitting code for EPSILON.

;;; Emitting code for NEGATIVE-EPSILON.

;;; Emitting code for SEQUENCEP.

;;; Emitting code for TYPEF.

;;; Emitting code for #:G433.

;;; Emitting code for PACKAGE-DESIGNATOR-P.

;;; Emitting code for #:G442.

;;; Emitting code for DEF-FOLD-TEST.

;;; Emitting code for EXPAND-IN-CURRENT-ENV.

ansi-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ansi-aux.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cl-symbols-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN IS-EXTERNAL-SYMBOL-OF ...).

;;; Compiling (DEFUN TEST-IF-NOT-IN-CL-PACKAGE ...).

;;; Compiling (DEFUN SAFE-SYMBOL-NAME ...).

;;; Compiling (DEFUN SAFE-MAKE-SYMBOL ...).

;;; End of Pass 1.

;;; Emitting code for IS-EXTERNAL-SYMBOL-OF.

;;; Emitting code for TEST-IF-NOT-IN-CL-PACKAGE.

;;; Emitting code for SAFE-SYMBOL-NAME.

;;; Emitting code for #:G14.

;;; Emitting code for #:G15.

;;; Emitting code for SAFE-MAKE-SYMBOL.

;;; Emitting code for #:G24.

;;; Emitting code for #:G25.

cl-symbols-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cl-symbols-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cl-symbols-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cl-symbols-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cl-symbols-aux.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/types-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN CLASSES-ARE-DISJOINT ...).

;;; Compiling (DEFUN TYPES.6-BODY ...).

;;; Compiling (DEFPARAMETER *TYPE-LIST* ...).

;;; Compiling (DEFPARAMETER *SUPERTYPE-TABLE* ...).

;;; Compiling (DEFUN TYPES.9-BODY ...).

;;; Compiling (DEFUN TYPES.9A-BODY ...).

;;; Compiling (DEFUN CHECK-SUBTYPEP ...).

;;; Compiling (DEFUN CHECK-DISJOINTNESS ...).

;;; Compiling (DEFUN CHECK-EQUIVALENCE ...).

;;; Compiling (DEFUN CHECK-ALL-SUBTYPEP ...).

;;; Compiling (DEFUN CHECK-ALL-NOT-SUBTYPEP ...).

;;; Compiling (DEFUN SUBTYPEP-AND-CONTRAPOSITIVE-ARE-CONSISTENT ...).

;;; End of Pass 1.

;;; Emitting code for CLASSES-ARE-DISJOINT.

;;; Emitting code for TYPES.6-BODY.

;;; Emitting code for TYPES.9-BODY.

;;; Emitting code for TYPES.9A-BODY.

;;; Emitting code for #:G43.

;;; Emitting code for #:G52.

;;; Emitting code for CHECK-SUBTYPEP.

;;; Emitting code for CHECK-DISJOINTNESS.

;;; Emitting code for CHECK-EQUIVALENCE.

;;; Emitting code for CHECK-ALL-SUBTYPEP.

;;; Emitting code for CHECK-ALL-NOT-SUBTYPEP.

;;; Emitting code for SUBTYPEP-AND-CONTRAPOSITIVE-ARE-CONSISTENT.

;;; Emitting code for EVEN-ARRAY.

types-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/types-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/types-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/types-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/types-aux.fas" NIL NIL) ;;; Warning: Redefining test LOOP.10.106



;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defclass-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MAKE-DEFCLASS-TEST-NAME ...).

;;; Compiling (DEFPARAMETER *DEFCLASS-SLOT-READERS* ...).

;;; Compiling (DEFPARAMETER *DEFCLASS-SLOT-WRITERS* ...).

;;; Compiling (DEFPARAMETER *DEFCLASS-SLOT-ACCESSORS* ...).

;;; Compiling (DEFUN MAKE-MY-CLASS ...).

;;; Compiling (DEFUN MAKE-MY-SLOT ...).

;;; Compiling (DEFPARAMETER *MY-CLASSES* ...).

;;; Compiling (DEFUN FIND-MY-CLASS ...).

;;; Compiling (DEFMACRO DEFCLASS-WITH-TESTS ...).

;;; Compiling (DEFUN DEFCLASS-ALLOCATE-INSTANCE-TEST ...).

;;; Compiling (DEFMACRO GENERATE-SLOT-TESTS ...).

;;; Compiling (DEFUN MY-COMPUTE-CLASS-PRECEDENCE-LIST ...).

;;; End of Pass 1.

;;; Emitting code for MAKE-DEFCLASS-TEST-NAME.

;;; Emitting code for MAKE-MY-CLASS.

;;; Emitting code for MAKE-MY-SLOT.

;;; Emitting code for FIND-MY-CLASS.

;;; Emitting code for DEFCLASS-WITH-TESTS.

;;; Emitting code for #:G225.

;;; Emitting code for #:G226.

;;; Emitting code for #:G233.

;;; Emitting code for #:G234.

;;; Emitting code for #:G237.

;;; Emitting code for #:G242.

;;; Emitting code for #:G243.

;;; Emitting code for #:G250.

;;; Emitting code for #:G251.

;;; Emitting code for #:G254.

;;; Emitting code for #:G261.

;;; Emitting code for #:G262.

;;; Emitting code for #:G265.

;;; Emitting code for #:G270.

;;; Emitting code for #:G271.

;;; Emitting code for #:G278.

;;; Emitting code for #:G279.

;;; Emitting code for #:G291.

;;; Emitting code for #:G292.

;;; Emitting code for #:G299.

;;; Emitting code for #:G300.

;;; Emitting code for #:G339.

;;; Emitting code for #:G340.

;;; Emitting code for #:G348.

;;; Emitting code for #:G349.

;;; Emitting code for DEFCLASS-ALLOCATE-INSTANCE-TEST.

;;; Emitting code for GENERATE-SLOT-TESTS.

;;; Emitting code for MY-COMPUTE-CLASS-PRECEDENCE-LIST.

;;; Emitting code for #:G401.

;;; Emitting code for #:G402.

;;; Emitting code for #:G409.

;;; Emitting code for #:G410.

;;; Emitting code for #:G437.

;;; Emitting code for #:G438.

;;; Emitting code for #:G447.

;;; Emitting code for #:G448.

;;; Emitting code for #:G467.

;;; Emitting code for #:G468.

defclass-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defclass-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defclass-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defclass-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defclass-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defgeneric-method-combination-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFCLASS DGMC-CLASS-01 ...).

;;; Compiling (DEFCLASS DGMC-CLASS-02 ...).

;;; Compiling (DEFCLASS DGMC-CLASS-03 ...).

;;; Compiling (DEFCLASS DGMC-CLASS-04 ...).

;;; Compiling (DEFCLASS DGMC-CLASS-05 ...).

;;; Compiling (DEFCLASS DGMC-CLASS-06 ...).

;;; Compiling (DEFCLASS DGMC-CLASS-07 ...).

;;; End of Pass 1.defgeneric-method-combination-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defgeneric-method-combination-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defgeneric-method-combination-aux.exp


;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defgeneric-method-combination-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/defgeneric-method-combination-aux.fas"

 NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/define-condition-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MAKE-DEF-COND-NAME ...).

;;; Compiling (DEFMACRO DEFINE-CONDITION-WITH-TESTS ...).

;;; End of Pass 1.

;;; Emitting code for MAKE-DEF-COND-NAME.

;;; Emitting code for DEFINE-CONDITION-WITH-TESTS.

;;; Emitting code for #:G86.

;;; Emitting code for #:G87.

;;; Emitting code for #:G99.

;;; Emitting code for #:G100.

;;; Emitting code for #:G123.

define-condition-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/define-condition-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/define-condition-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/define-condition-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/define-condition-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cons-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MAKE-SCAFFOLD ...).

;;; Compiling (DEFUN MAKE-SCAFFOLD-COPY ...).

;;; Compiling (DEFUN CHECK-SCAFFOLD-COPY ...).

;;; Compiling (DEFUN CREATE-C*R-TEST ...).

;;; Compiling (DEFUN NTH-1-BODY ...).

;;; Compiling (DEFUN CHECK-CONS-COPY ...).

;;; Compiling (DEFUN CHECK-SUBLIS ...).

;;; Compiling (DEFUN CHECK-NSUBLIS ...).

;;; Compiling (DEFUN CHECK-SUBST ...).

;;; Compiling (DEFUN CHECK-SUBST-IF ...).

;;; Compiling (DEFUN CHECK-SUBST-IF-NOT ...).

;;; Compiling (DEFUN CHECK-NSUBST ...).

;;; Compiling (DEFUN CHECK-NSUBST-IF ...).

;;; Compiling (DEFUN CHECK-NSUBST-IF-NOT ...).

;;; Compiling (DEFUN CHECK-COPY-LIST-COPY ...).

;;; Compiling (DEFUN CHECK-COPY-LIST ...).

;;; Compiling (DEFUN APPEND-6-BODY ...).

;;; Compiling (DEFUN IS-INTERSECTION ...).

;;; Compiling (DEFUN SHUFFLE ...).

;;; Compiling (DEFUN SPLIT-LIST ...).

;;; Compiling (DEFUN INTERSECTION-12-BODY ...).

;;; Compiling (DEFUN NINTERSECTION-WITH-CHECK ...).

;;; Compiling (DEFUN NINTERSECTION-12-BODY ...).

;;; Compiling (DEFUN UNION-WITH-CHECK ...).

;;; Compiling (DEFUN UNION-WITH-CHECK-AND-KEY ...).

;;; Compiling (DEFUN CHECK-UNION ...).

;;; Compiling (DEFUN DO-RANDOM-UNIONS ...).

;;; Compiling (DEFUN NUNION-WITH-COPY ...).

;;; Compiling (DEFUN NUNION-WITH-COPY-AND-KEY ...).

;;; Compiling (DEFUN DO-RANDOM-NUNIONS ...).

;;; Compiling (DEFUN SET-DIFFERENCE-WITH-CHECK ...).

;;; Compiling (DEFUN CHECK-SET-DIFFERENCE ...).

;;; Compiling (DEFUN DO-RANDOM-SET-DIFFERENCES ...).

;;; Compiling (DEFUN NSET-DIFFERENCE-WITH-CHECK ...).

;;; Compiling (DEFUN CHECK-NSET-DIFFERENCE ...).

;;; Compiling (DEFUN DO-RANDOM-NSET-DIFFERENCES ...).

;;; Compiling (DEFUN SET-EXCLUSIVE-OR-WITH-CHECK ...).

;;; Compiling (DEFUN CHECK-SET-EXCLUSIVE-OR ...).

;;; Compiling (DEFUN NSET-EXCLUSIVE-OR-WITH-CHECK ...).

;;; Compiling (DEFUN SUBSETP-WITH-CHECK ...).

;;; Compiling (DEFUN MY-SET-EXCLUSIVE-OR ...).

;;; Compiling (DEFUN MAKE-RANDOM-SET-EXCLUSIVE-OR-INPUT ...).

;;; Compiling (DEFUN RANDOM-SET-EXCLUSIVE-OR-TEST ...).

;;; Compiling (DEFUN REV-ASSOC-LIST ...).

;;; Compiling (DEFVAR *MAPC.6-VAR* ...).

;;; Compiling (DEFUN MAPC.6-FUN ...).

;;; End of Pass 1.

;;; Emitting code for MAKE-SCAFFOLD.

;;; Emitting code for MAKE-SCAFFOLD-COPY.

;;; Emitting code for CHECK-SCAFFOLD-COPY.

;;; Emitting code for CREATE-C*R-TEST.

;;; Emitting code for NTH-1-BODY.

;;; Emitting code for CHECK-CONS-COPY.

;;; Emitting code for CHECK-SUBLIS.

;;; Emitting code for CHECK-NSUBLIS.

;;; Emitting code for CHECK-SUBST.

;;; Emitting code for CHECK-SUBST-IF.

;;; Emitting code for CHECK-SUBST-IF-NOT.

;;; Emitting code for CHECK-NSUBST.

;;; Emitting code for CHECK-NSUBST-IF.

;;; Emitting code for CHECK-NSUBST-IF-NOT.

;;; Emitting code for CHECK-COPY-LIST-COPY.

;;; Emitting code for CHECK-COPY-LIST.

;;; Emitting code for APPEND-6-BODY.

;;; Emitting code for IS-INTERSECTION.

;;; Emitting code for SHUFFLE.

;;; Emitting code for SPLIT-LIST.

;;; Emitting code for INTERSECTION-12-BODY.

;;; Emitting code for NINTERSECTION-WITH-CHECK.

;;; Emitting code for NINTERSECTION-12-BODY.

;;; Emitting code for UNION-WITH-CHECK.

;;; Emitting code for UNION-WITH-CHECK-AND-KEY.

;;; Emitting code for CHECK-UNION.

;;; Emitting code for DO-RANDOM-UNIONS.

;;; Emitting code for NUNION-WITH-COPY.

;;; Emitting code for NUNION-WITH-COPY-AND-KEY.

;;; Emitting code for DO-RANDOM-NUNIONS.

;;; Emitting code for SET-DIFFERENCE-WITH-CHECK.

;;; Emitting code for CHECK-SET-DIFFERENCE.

;;; Emitting code for DO-RANDOM-SET-DIFFERENCES.

;;; Emitting code for NSET-DIFFERENCE-WITH-CHECK.

;;; Emitting code for CHECK-NSET-DIFFERENCE.

;;; Emitting code for DO-RANDOM-NSET-DIFFERENCES.

;;; Emitting code for SET-EXCLUSIVE-OR-WITH-CHECK.

;;; Emitting code for CHECK-SET-EXCLUSIVE-OR.

;;; Emitting code for NSET-EXCLUSIVE-OR-WITH-CHECK.

;;; Emitting code for SUBSETP-WITH-CHECK.

;;; Emitting code for MY-SET-EXCLUSIVE-OR.

;;; Emitting code for #:G128.

;;; Emitting code for #:G129.

;;; Emitting code for MAKE-RANDOM-SET-EXCLUSIVE-OR-INPUT.

;;; Emitting code for RANDOM-SET-EXCLUSIVE-OR-TEST.

;;; Emitting code for REV-ASSOC-LIST.

;;; Emitting code for MAPC.6-FUN.

cons-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cons-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cons-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cons-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/cons-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/array-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MAKE-ARRAY-CHECK-UPGRADING ...).

;;; Compiling (DEFUN SUBTYPEP-OR-UNKNOWN ...).

;;; Compiling (DEFUN MAKE-ARRAY-WITH-CHECKS ...).

;;; End of Pass 1.

;;; Emitting code for MAKE-ARRAY-CHECK-UPGRADING.

;;; Emitting code for SUBTYPEP-OR-UNKNOWN.

;;; Emitting code for MAKE-ARRAY-WITH-CHECKS.

array-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/array-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/array-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/array-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/array-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/bit-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN BIT-RANDOM-TEST-FN ...).

;;; End of Pass 1.

;;; Emitting code for BIT-RANDOM-TEST-FN.

;;; Emitting code for #:G6.

;;; Emitting code for #:G7.

;;; Emitting code for #:G14.

;;; Emitting code for #:G15.

;;; Emitting code for #:G22.

bit-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/bit-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/bit-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/bit-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/bit-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/hash-table-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFPARAMETER *HASH-TABLE-TEST-ITERS* ...).

;;; Compiling (DEFUN TEST-HASH-TABLE-1 ...).

;;; End of Pass 1.

;;; Emitting code for TEST-HASH-TABLE-1.

;;; Emitting code for #:G7.

;;; Emitting code for #:G8.

;;; Emitting code for #:G15.

;;; Emitting code for #:G16.

;;; Emitting code for #:G23.

;;; Emitting code for #:G24.

;;; Emitting code for #:G33.

;;; Emitting code for #:G34.

;;; Emitting code for #:G41.

;;; Emitting code for #:G42.

;;; Emitting code for %REMOVE-PAIR.

;;; Emitting code for #:G99.

;;; Emitting code for #:G100.

;;; Emitting code for #:G107.

;;; Emitting code for #:G108.

;;; Emitting code for #:G122.

;;; Emitting code for #:G123.

;;; Emitting code for #:G138.

;;; Emitting code for #:G139.

;;; Emitting code for #:G146.

;;; Emitting code for #:G147.

;;; Emitting code for #:G156.

;;; Emitting code for #:G157.

;;; Emitting code for #:G54.

;;; Emitting code for #:G55.

;;; Emitting code for #:G62.

;;; Emitting code for #:G63.

;;; Emitting code for #:G71.

;;; Emitting code for #:G72.

;;; Emitting code for #:G80.

;;; Emitting code for #:G81.

;;; Emitting code for #:G88.

;;; Emitting code for #:G89.

hash-table-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/hash-table-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/hash-table-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/hash-table-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/hash-table-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/packages-00.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN SET-UP-PACKAGES ...).

;;; End of Pass 1.

;;; Emitting code for #:G9.

;;; Emitting code for #:G19.

;;; Emitting code for SET-UP-PACKAGES.

;;; Emitting code for #:G29.

;;; Emitting code for #:G39.

;;; Emitting code for #:G49.

;;; Emitting code for #:G59.

;;; Emitting code for #:G69.

;;; Emitting code for #:G79.

packages-00.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/packages-00.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/packages-00.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/packages-00.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/packages-00.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/package-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFMACRO TEST-WITH-PACKAGE-ITERATOR ...).

;;; Compiling (DEFUN WITH-PACKAGE-ITERATOR-INTERNAL ...).

;;; Compiling (DEFUN WITH-PACKAGE-ITERATOR-EXTERNAL ...).

;;; Compiling (DEFUN WITH-PACKAGE-ITERATOR-INHERITED ...).

;;; Compiling (DEFUN WITH-PACKAGE-ITERATOR-ALL ...).

;;; Compiling (DEFUN NUM-EXTERNAL-SYMBOLS-IN-PACKAGE ...).

;;; Compiling (DEFUN EXTERNAL-SYMBOLS-IN-PACKAGE ...).

;;; Compiling (DEFUN NUM-SYMBOLS-IN-PACKAGE ...).

;;; Compiling (DEFUN SORT-SYMBOLS ...).

;;; Compiling (DEFUN SORT-PACKAGE-LIST ...).

;;; End of Pass 1.

;;; Emitting code for TEST-WITH-PACKAGE-ITERATOR.

;;; Emitting code for WITH-PACKAGE-ITERATOR-INTERNAL.

;;; Emitting code for WITH-PACKAGE-ITERATOR-EXTERNAL.

;;; Emitting code for WITH-PACKAGE-ITERATOR-INHERITED.

;;; Emitting code for WITH-PACKAGE-ITERATOR-ALL.

;;; Emitting code for NUM-EXTERNAL-SYMBOLS-IN-PACKAGE.

;;; Emitting code for EXTERNAL-SYMBOLS-IN-PACKAGE.

;;; Emitting code for #:G153.

;;; Emitting code for NUM-SYMBOLS-IN-PACKAGE.

;;; Emitting code for SORT-SYMBOLS.

;;; Emitting code for #:G164.

;;; Emitting code for SORT-PACKAGE-LIST.

package-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/package-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/package-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/package-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/package-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/numbers-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN FLOAT-BINARY-SEARCH ...).

;;; Compiling (DEFUN INTEGER-BINARY-SEARCH ...).

;;; Compiling (DEFUN FIND-LARGEST-EXACTLY-FLOATABLE-INTEGER ...).

;;; Compiling (DEFUN EQLZT ...).

;;; Compiling (DEFUN FLOAT-EXPONENT ...).

;;; Compiling (DEFUN NUMBERS-ARE-COMPATIBLE ...).

;;; Compiling (DEFUN =.4-FN ...).

;;; Compiling (DEFUN /=.4-FN ...).

;;; Compiling (DEFUN /=.4A-FN ...).

;;; Compiling (DEFUN <.8-FN ...).

;;; Compiling (DEFUN <.9-FN ...).

;;; Compiling (DEFUN <.10-FN ...).

;;; Compiling (DEFUN <=.8-FN ...).

;;; Compiling (DEFUN <=.9-FN ...).

;;; Compiling (DEFUN >.8-FN ...).

;;; Compiling (DEFUN >=.8-FN ...).

;;; Compiling (DEFUN COMPARE-RANDOM-RATIONALS ...).

;;; Compiling (DEFUN MAX.2-FN ...).

;;; Compiling (DEFUN MIN.2-FN ...).

;;; Compiling (DEFUN FIND-EPSILON ...).

;;; Compiling (DEFUN TEST-LOG-OP-WITH-DECLS ...).

;;; Compiling (DEFUN TEST-LOG-OP ...).

;;; Compiling (DEFUN SAFE-TAN ...).

;;; End of Pass 1.

;;; Emitting code for FLOAT-BINARY-SEARCH.

;;; Emitting code for #:G6.

;;; Emitting code for #:G7.

;;; Emitting code for #:G14.

;;; Emitting code for #:G15.

;;; Emitting code for #:G22.

;;; Emitting code for #:G23.

;;; Emitting code for #:G30.

;;; Emitting code for #:G31.

;;; Emitting code for #:G38.

;;; Emitting code for #:G39.

;;; Emitting code for INTEGER-BINARY-SEARCH.

;;; Emitting code for #:G47.

;;; Emitting code for #:G48.

;;; Emitting code for #:G55.

;;; Emitting code for #:G56.

;;; Emitting code for #:G63.

;;; Emitting code for #:G64.

;;; Emitting code for #:G71.

;;; Emitting code for #:G72.

;;; Emitting code for #:G79.

;;; Emitting code for #:G80.

;;; Emitting code for FIND-LARGEST-EXACTLY-FLOATABLE-INTEGER.

;;; Emitting code for #:G82.

;;; Emitting code for EQLZT.

;;; Emitting code for FLOAT-EXPONENT.

;;; Emitting code for NUMBERS-ARE-COMPATIBLE.

;;; Emitting code for =.4-FN.

;;; Emitting code for /=.4-FN.

;;; Emitting code for /=.4A-FN.

;;; Emitting code for <.8-FN.

;;; Emitting code for #:G140.

;;; Emitting code for <.9-FN.

;;; Emitting code for #:G158.

;;; Emitting code for <.10-FN.

;;; Emitting code for #:G176.

;;; Emitting code for <=.8-FN.

;;; Emitting code for #:G194.

;;; Emitting code for <=.9-FN.

;;; Emitting code for #:G212.

;;; Emitting code for >.8-FN.

;;; Emitting code for #:G232.

;;; Emitting code for >=.8-FN.

;;; Emitting code for #:G250.

;;; Emitting code for COMPARE-RANDOM-RATIONALS.

;;; Emitting code for MAX.2-FN.

;;; Emitting code for #:G285.

;;; Emitting code for #:G286.

;;; Emitting code for MIN.2-FN.

;;; Emitting code for #:G307.

;;; Emitting code for #:G308.

;;; Emitting code for FIND-EPSILON.

;;; Emitting code for #:G316.

;;; Emitting code for #:G317.

;;; Emitting code for TEST-LOG-OP-WITH-DECLS.

;;; Emitting code for #:G325.

;;; Emitting code for #:G326.

;;; Emitting code for #:G333.

;;; Emitting code for #:G334.

;;; Emitting code for #:G341.

;;; Emitting code for #:G342.

;;; Emitting code for #:G349.

;;; Emitting code for #:G350.

;;; Emitting code for #:G357.

;;; Emitting code for #:G358.

;;; Emitting code for #:G365.

;;; Emitting code for #:G366.

;;; Emitting code for #:G373.

;;; Emitting code for #:G374.

;;; Emitting code for #:G381.

;;; Emitting code for #:G382.

;;; Emitting code for TEST-LOG-OP.

;;; Emitting code for %R.

;;; Emitting code for SAFE-TAN.

;;; Emitting code for #:G406.

;;; Emitting code for #:G415.

;;; Emitting code for #:G416.

numbers-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/numbers-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/numbers-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/numbers-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/numbers-aux.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/floor-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN FLOOR.1-FN ...).

;;; Compiling (DEFUN FLOOR.2-FN ...).

;;; Compiling (DEFUN FLOOR.3-FN ...).

;;; Compiling (DEFUN FLOOR.7-FN ...).

;;; Compiling (DEFUN FLOOR.8-FN ...).

;;; Compiling (DEFUN FLOOR.9-FN ...).

;;; End of Pass 1.

;;; Emitting code for FLOOR.1-FN.

;;; Emitting code for FLOOR.2-FN.

;;; Emitting code for FLOOR.3-FN.

;;; Emitting code for FLOOR.7-FN.

;;; Emitting code for FLOOR.8-FN.

;;; Emitting code for FLOOR.9-FN.

floor-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/floor-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/floor-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/floor-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/floor-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ffloor-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN FFLOOR.1-FN ...).

;;; End of Pass 1.

;;; Emitting code for FFLOOR.1-FN.

ffloor-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ffloor-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ffloor-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ffloor-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ffloor-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ceiling-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN CEILING.1-FN ...).

;;; Compiling (DEFUN CEILING.2-FN ...).

;;; Compiling (DEFUN CEILING.3-FN ...).

;;; Compiling (DEFUN CEILING.7-FN ...).

;;; Compiling (DEFUN CEILING.8-FN ...).

;;; Compiling (DEFUN CEILING.9-FN ...).

;;; End of Pass 1.

;;; Emitting code for CEILING.1-FN.

;;; Emitting code for CEILING.2-FN.

;;; Emitting code for CEILING.3-FN.

;;; Emitting code for CEILING.7-FN.

;;; Emitting code for CEILING.8-FN.

;;; Emitting code for CEILING.9-FN.

ceiling-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ceiling-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ceiling-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ceiling-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ceiling-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fceiling-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN FCEILING.1-FN ...).

;;; End of Pass 1.

;;; Emitting code for FCEILING.1-FN.

fceiling-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fceiling-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fceiling-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fceiling-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fceiling-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/truncate-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN TRUNCATE.1-FN ...).

;;; Compiling (DEFUN TRUNCATE.2-FN ...).

;;; Compiling (DEFUN TRUNCATE.3-FN ...).

;;; Compiling (DEFUN TRUNCATE.7-FN ...).

;;; Compiling (DEFUN TRUNCATE.8-FN ...).

;;; Compiling (DEFUN TRUNCATE.9-FN ...).

;;; End of Pass 1.

;;; Emitting code for TRUNCATE.1-FN.

;;; Emitting code for TRUNCATE.2-FN.

;;; Emitting code for TRUNCATE.3-FN.

;;; Emitting code for TRUNCATE.7-FN.

;;; Emitting code for TRUNCATE.8-FN.

;;; Emitting code for TRUNCATE.9-FN.

truncate-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/truncate-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/truncate-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/truncate-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/truncate-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ftruncate-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN FTRUNCATE.1-FN ...).

;;; End of Pass 1.

;;; Emitting code for FTRUNCATE.1-FN.

ftruncate-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ftruncate-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ftruncate-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ftruncate-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/ftruncate-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/round-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN ROUND.1-FN ...).

;;; Compiling (DEFUN ROUND.2-FN ...).

;;; Compiling (DEFUN ROUND.3-FN ...).

;;; Compiling (DEFUN ROUND.7-FN ...).

;;; Compiling (DEFUN ROUND.8-FN ...).

;;; Compiling (DEFUN ROUND.9-FN ...).

;;; End of Pass 1.

;;; Emitting code for ROUND.1-FN.

;;; Emitting code for ROUND.2-FN.

;;; Emitting code for ROUND.3-FN.

;;; Emitting code for ROUND.7-FN.

;;; Emitting code for ROUND.8-FN.

;;; Emitting code for ROUND.9-FN.

round-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/round-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/round-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/round-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/round-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fround-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN FROUND.1-FN ...).

;;; End of Pass 1.

;;; Emitting code for FROUND.1-FN.

fround-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fround-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fround-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fround-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/fround-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/times-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN INTEGER-TIMES ...).

;;; Compiling (DEFUN NAT-TIMES ...).

;;; Compiling (DEFUN RAT-TIMES ...).

;;; End of Pass 1.

;;; Emitting code for INTEGER-TIMES.

;;; Emitting code for #:G6.

;;; Emitting code for #:G7.

;;; Emitting code for #:G14.

;;; Emitting code for #:G15.

;;; Emitting code for NAT-TIMES.

;;; Emitting code for RAT-TIMES.

times-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/times-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/times-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/times-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/times-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/division-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN DIVIDE-BY-ZERO-TEST ...).

;;; End of Pass 1.

;;; Emitting code for DIVIDE-BY-ZERO-TEST.

;;; Emitting code for #:G8.

;;; Emitting code for #:G9.

division-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/division-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/division-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/division-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/division-aux.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/exp-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MY-EXP ...).

;;; End of Pass 1.

;;; Emitting code for MY-EXP.

;;; Emitting code for #:G6.

;;; Emitting code for #:G7.

exp-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/exp-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/exp-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/exp-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/exp-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/gcd-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MY-GCD ...).

;;; Compiling (DEFUN MY-GCD* ...).

;;; Compiling (DEFUN MY-LCM ...).

;;; End of Pass 1.

;;; Emitting code for MY-GCD.

;;; Emitting code for MY-GCD*.

;;; Emitting code for MY-LCM.

gcd-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/gcd-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/gcd-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/gcd-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/gcd-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/search-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFPARAMETER *SEARCHED-LIST* ...).

;;; Compiling (DEFPARAMETER *PATTERN-SUBLISTS* ...).

;;; Compiling (DEFPARAMETER *SEARCHED-VECTOR* ...).

;;; Compiling (DEFPARAMETER *PATTERN-SUBVECTORS* ...).

;;; Compiling (DEFPARAMETER *SEARCHED-BITVECTOR* ...).

;;; Compiling (DEFPARAMETER *PATTERN-SUBBITVECTORS* ...).

;;; Compiling (DEFPARAMETER *SEARCHED-STRING* ...).

;;; Compiling (DEFPARAMETER *PATTERN-SUBSTRINGS* ...).

;;; Compiling (DEFUN SUBSEQ-EQUALP ...).

;;; Compiling (DEFUN SEARCH-CHECK ...).

;;; End of Pass 1.

;;; Emitting code for SUBSEQ-EQUALP.

;;; Emitting code for #:G38.

;;; Emitting code for #:G39.

;;; Emitting code for SEARCH-CHECK.

;;; Emitting code for #:G50.

;;; Emitting code for #:G51.

;;; Emitting code for #:G58.

;;; Emitting code for #:G59.

search-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/search-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/search-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/search-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/search-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/subseq-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN SUBSEQ-LIST.4-BODY ...).

;;; Compiling (DEFUN SUBSEQ-LIST.5-BODY ...).

;;; Compiling (DEFUN SUBSEQ-LIST.6-BODY ...).

;;; Compiling (DEFUN SUBSEQ-VECTOR.1-BODY ...).

;;; Compiling (DEFUN SUBSEQ-VECTOR.2-BODY ...).

;;; Compiling (DEFUN SUBSEQ-VECTOR.3-BODY ...).

;;; Compiling (DEFUN SUBSEQ-VECTOR.4-BODY ...).

;;; Compiling (DEFUN SUBSEQ-VECTOR.5-BODY ...).

;;; Compiling (DEFUN SUBSEQ-VECTOR.6-BODY ...).

;;; Compiling (DEFUN SUBSEQ-STRING.1-BODY ...).

;;; Compiling (DEFUN SUBSEQ-STRING.2-BODY ...).

;;; Compiling (DEFUN SUBSEQ-STRING.3-BODY ...).

;;; Compiling (DEFUN SUBSEQ-BIT-VECTOR.1-BODY ...).

;;; Compiling (DEFUN SUBSEQ-BIT-VECTOR.2-BODY ...).

;;; Compiling (DEFUN SUBSEQ-BIT-VECTOR.3-BODY ...).

;;; End of Pass 1.

;;; Emitting code for SUBSEQ-LIST.4-BODY.

;;; Emitting code for SUBSEQ-LIST.5-BODY.

;;; Emitting code for SUBSEQ-LIST.6-BODY.

;;; Emitting code for SUBSEQ-VECTOR.1-BODY.

;;; Emitting code for #:G17.

;;; Emitting code for #:G18.

;;; Emitting code for #:G22.

;;; Emitting code for #:G27.

;;; Emitting code for SUBSEQ-VECTOR.2-BODY.

;;; Emitting code for #:G28.

;;; Emitting code for #:G29.

;;; Emitting code for #:G33.

;;; Emitting code for #:G38.

;;; Emitting code for SUBSEQ-VECTOR.3-BODY.

;;; Emitting code for #:G39.

;;; Emitting code for #:G40.

;;; Emitting code for #:G44.

;;; Emitting code for #:G49.

;;; Emitting code for SUBSEQ-VECTOR.4-BODY.

;;; Emitting code for #:G50.

;;; Emitting code for #:G51.

;;; Emitting code for #:G55.

;;; Emitting code for #:G60.

;;; Emitting code for SUBSEQ-VECTOR.5-BODY.

;;; Emitting code for #:G61.

;;; Emitting code for #:G62.

;;; Emitting code for #:G66.

;;; Emitting code for #:G71.

;;; Emitting code for SUBSEQ-VECTOR.6-BODY.

;;; Emitting code for #:G72.

;;; Emitting code for #:G73.

;;; Emitting code for #:G77.

;;; Emitting code for #:G82.

;;; Emitting code for SUBSEQ-STRING.1-BODY.

;;; Emitting code for SUBSEQ-STRING.2-BODY.

;;; Emitting code for SUBSEQ-STRING.3-BODY.

;;; Emitting code for SUBSEQ-BIT-VECTOR.1-BODY.

;;; Emitting code for SUBSEQ-BIT-VECTOR.2-BODY.

;;; Emitting code for SUBSEQ-BIT-VECTOR.3-BODY.

subseq-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/subseq-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/subseq-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/subseq-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/subseq-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MAKE-RANDOM-ELEMENT ...).

;;; Compiling (DEFUN MAKE-RANDOM-REMOVE-INPUT ...).

;;; Compiling (DEFUN MY-REMOVE ...).

;;; Compiling (DEFUN MY-REMOVE-IF ...).

;;; Compiling (DEFUN MY-REMOVE-IF-NOT ...).

;;; Compiling (DEFUN MAKE-RANDOM-RD-PARAMS ...).

;;; Compiling (DEFUN RANDOM-TEST-REMOVE-ARGS ...).

;;; Compiling (DEFPARAMETER *REMOVE-FAIL-ARGS* ...).

;;; Compiling (DEFUN RANDOM-TEST-REMOVE ...).

;;; Compiling (DEFUN RANDOM-TEST-REMOVE-IF ...).

;;; Compiling (DEFUN RANDOM-TEST-DELETE ...).

;;; Compiling (DEFUN RANDOM-TEST-DELETE-IF ...).

;;; End of Pass 1.

;;; Emitting code for MAKE-RANDOM-ELEMENT.

;;; Emitting code for MAKE-RANDOM-REMOVE-INPUT.

;;; Emitting code for MY-REMOVE.

;;; Emitting code for #:G16.

;;; Emitting code for #:G17.

;;; Emitting code for #:G20.

;;; Emitting code for #:G22.

;;; Emitting code for #:G23.

;;; Emitting code for MY-REMOVE-IF.

;;; Emitting code for #:G29.

;;; Emitting code for #:G30.

;;; Emitting code for #:G37.

;;; Emitting code for #:G38.

;;; Emitting code for #:G45.

;;; Emitting code for #:G46.

;;; Emitting code for #:G53.

;;; Emitting code for #:G54.

;;; Emitting code for #:G61.

;;; Emitting code for #:G62.

;;; Emitting code for #:G66.

;;; Emitting code for MY-REMOVE-IF-NOT.

;;; Emitting code for #:G77.

;;; Emitting code for #:G78.

;;; Emitting code for MAKE-RANDOM-RD-PARAMS.

;;; Emitting code for #:G85.

;;; Emitting code for RANDOM-TEST-REMOVE-ARGS.

;;; Emitting code for RANDOM-TEST-REMOVE.

;;; Emitting code for RANDOM-TEST-REMOVE-IF.

;;; Emitting code for #:G106.

;;; Emitting code for RANDOM-TEST-DELETE.

;;; Emitting code for RANDOM-TEST-DELETE-IF.

;;; Emitting code for #:G120.

remove-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-duplicates-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MY-REMOVE-DUPLICATES ...).

;;; Compiling (DEFUN MAKE-RANDOM-RDUP-PARAMS ...).

;;; Compiling (DEFUN RANDOM-TEST-REMOVE-DUPS ...).

;;; End of Pass 1.

;;; Emitting code for MY-REMOVE-DUPLICATES.

;;; Emitting code for #:G6.

;;; Emitting code for #:G7.

;;; Emitting code for #:G16.

;;; Emitting code for #:G17.

;;; Emitting code for #:G20.

;;; Emitting code for #:G26.

;;; Emitting code for #:G27.

;;; Emitting code for #:G34.

;;; Emitting code for #:G35.

;;; Emitting code for #:G42.

;;; Emitting code for #:G43.

;;; Emitting code for #:G50.

;;; Emitting code for #:G51.

;;; Emitting code for #:G69.

;;; Emitting code for #:G70.

;;; Emitting code for MAKE-RANDOM-RDUP-PARAMS.

;;; Emitting code for RANDOM-TEST-REMOVE-DUPS.

remove-duplicates-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-duplicates-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-duplicates-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-duplicates-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/remove-duplicates-aux.fas" NIL

 NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/string-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MY-STRING-COMPARE ...).

;;; Compiling (DEFUN MAKE-RANDOM-STRING-COMPARE-TEST ...).

;;; Compiling (DEFUN RANDOM-STRING-COMPARE-TEST ...).

;;; Compiling (DEFUN STRING-ALL-THE-SAME ...).

;;; End of Pass 1.

;;; Emitting code for MY-STRING-COMPARE.

;;; Emitting code for #:G6.

;;; Emitting code for #:G7.

;;; Emitting code for #:G14.

;;; Emitting code for #:G15.

;;; Emitting code for #:G23.

;;; Emitting code for #:G24.

;;; Emitting code for #:G31.

;;; Emitting code for #:G32.

;;; Emitting code for #:G39.

;;; Emitting code for #:G40.

;;; Emitting code for #:G47.

;;; Emitting code for #:G48.

;;; Emitting code for MAKE-RANDOM-STRING-COMPARE-TEST.

;;; Emitting code for RANDOM-STRING-COMPARE-TEST.

;;; Emitting code for STRING-ALL-THE-SAME.

string-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/string-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/string-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/string-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/string-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/char-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN IS-ORDERED-BY ...).

;;; Compiling (DEFUN IS-ANTISYMMETRICALLY-ORDERED-BY ...).

;;; Compiling (DEFUN IS-CASE-INSENSITIVE ...).

;;; Compiling (DEFUN EQUIV ...).

;;; Compiling (DEFUN CHAR-TYPE-ERROR-CHECK ...).

;;; Compiling (DEFUN STANDARD-CHAR.5.BODY ...).

;;; Compiling (DEFUN EXTENDED-CHAR.3.BODY ...).

;;; Compiling (DEFUN CHARACTER.1.BODY ...).

;;; Compiling (DEFUN CHARACTER.2.BODY ...).

;;; Compiling (DEFUN CHARACTERP.2.BODY ...).

;;; Compiling (DEFUN CHARACTERP.3.BODY ...).

;;; Compiling (DEFUN ALPHANUMERICP.4.BODY ...).

;;; Compiling (DEFUN ALPHANUMERICP.5.BODY ...).

;;; Compiling (DEFUN DIGIT-CHAR.1.BODY.OLD ...).

;;; Compiling (DEFUN DIGIT-CHAR.1.BODY ...).

;;; Compiling (DEFUN DIGIT-CHAR-P.1.BODY ...).

;;; Compiling (DEFUN DIGIT-CHAR-P.2.BODY ...).

;;; Compiling (DEFUN DIGIT-CHAR-P.3.BODY ...).

;;; Compiling (DEFUN DIGIT-CHAR-P.4.BODY ...).

;;; Compiling (DEFUN STANDARD-CHAR-P.2.BODY ...).

;;; Compiling (DEFUN STANDARD-CHAR-P.2A.BODY ...).

;;; Compiling (DEFUN CHAR-UPCASE.1.BODY ...).

;;; Compiling (DEFUN CHAR-UPCASE.2.BODY ...).

;;; Compiling (DEFUN CHAR-DOWNCASE.1.BODY ...).

;;; Compiling (DEFUN CHAR-DOWNCASE.2.BODY ...).

;;; Compiling (DEFUN BOTH-CASE-P.1.BODY ...).

;;; Compiling (DEFUN BOTH-CASE-P.2.BODY ...).

;;; Compiling (DEFUN CHAR-CODE.2.BODY ...).

;;; Compiling (DEFUN CHAR-INT.2.FN ...).

;;; Compiling (DEFUN CHAR-NAME.1.FN ...).

;;; Compiling (DEFUN NAME-CHAR.1.BODY ...).

;;; End of Pass 1.

;;; Emitting code for IS-ORDERED-BY.

;;; Emitting code for IS-ANTISYMMETRICALLY-ORDERED-BY.

;;; Emitting code for IS-CASE-INSENSITIVE.

;;; Emitting code for #:G14.

;;; Emitting code for #:G15.

;;; Emitting code for #:G23.

;;; Emitting code for #:G24.

;;; Emitting code for EQUIV.

;;; Emitting code for CHAR-TYPE-ERROR-CHECK.

;;; Emitting code for #:G42.

;;; Emitting code for #:G43.

;;; Emitting code for #:G51.

;;; Emitting code for #:G52.

;;; Emitting code for #:G64.

;;; Emitting code for #:G65.

;;; Emitting code for STANDARD-CHAR.5.BODY.

;;; Emitting code for EXTENDED-CHAR.3.BODY.

;;; Emitting code for CHARACTER.1.BODY.

;;; Emitting code for CHARACTER.2.BODY.

;;; Emitting code for #:G85.

;;; Emitting code for #:G86.

;;; Emitting code for #:G96.

;;; Emitting code for #:G97.

;;; Emitting code for CHARACTERP.2.BODY.

;;; Emitting code for CHARACTERP.3.BODY.

;;; Emitting code for ALPHANUMERICP.4.BODY.

;;; Emitting code for ALPHANUMERICP.5.BODY.

;;; Emitting code for DIGIT-CHAR.1.BODY.OLD.

;;; Emitting code for DIGIT-CHAR.1.BODY.

;;; Emitting code for DIGIT-CHAR-P.1.BODY.

;;; Emitting code for DIGIT-CHAR-P.2.BODY.

;;; Emitting code for DIGIT-CHAR-P.3.BODY.

;;; Emitting code for DIGIT-CHAR-P.4.BODY.

;;; Emitting code for STANDARD-CHAR-P.2.BODY.

;;; Emitting code for STANDARD-CHAR-P.2A.BODY.

;;; Emitting code for CHAR-UPCASE.1.BODY.

;;; Emitting code for CHAR-UPCASE.2.BODY.

;;; Emitting code for CHAR-DOWNCASE.1.BODY.

;;; Emitting code for CHAR-DOWNCASE.2.BODY.

;;; Emitting code for BOTH-CASE-P.1.BODY.

;;; Emitting code for BOTH-CASE-P.2.BODY.

;;; Emitting code for CHAR-CODE.2.BODY.

;;; Emitting code for CHAR-INT.2.FN.

;;; Emitting code for %INSERT.

;;; Emitting code for CHAR-NAME.1.FN.

;;; Emitting code for %CHECK.

;;; Emitting code for NAME-CHAR.1.BODY.

;;; Emitting code for #:G180.

;;; Emitting code for #:G181.

char-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/char-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/char-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/char-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/char-aux.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/pathnames-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN COULD-BE-PATHNAME-DESIGNATOR ...).

;;; Compiling (DEFUN EXPLODE-PATHNAME ...).

;;; End of Pass 1.

;;; Emitting code for COULD-BE-PATHNAME-DESIGNATOR.

;;; Emitting code for EXPLODE-PATHNAME.

pathnames-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/pathnames-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/pathnames-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/pathnames-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/pathnames-aux.fas" NIL NIL) EFF4E.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF4E.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF4E.exp


;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/printer-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFMACRO DEF-PRINT-TEST ...).

;;; Compiling (DEFMACRO DEF-PPRINT-TEST ...).

;;; Compiling (DEFMACRO DEF-PPBLOCK-TEST ...).

;;; Compiling (DEFVAR *RANDOM-READ-CHECK-DEBUG* ...).

;;; Compiling (DEFUN RANDOMLY-CHECK-READABILITY ...).

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.

;;; Compiling (DEFUN PARSE-ESCAPED-STRING ...).

;;; Compiling (DEFUN ESCAPED-EQUAL ...).

;;; Compiling (DEFUN SIMILAR-UNINTERNED-SYMBOLS ...).

;;; Compiling (DEFUN MAKE-RANDOM-CONS-TREE ...).

;;; Compiling (DEFUN MAKE-RANDOM-VECTOR ...).

;;; Compiling (DEFUN FUNCALL-WITH-PRINT-BINDINGS ...).

;;; Compiling (DEFUN OUTPUT-TEST ...).

;;; Compiling (DEFUN MAKE-RANDOM-KEY-PARAM ...).

;;; Compiling (DEFUN MAKE-RANDOM-KEY-INTEGER-OR-NIL-PARAM ...).

;;; Compiling (DEFUN MAKE-RANDOM-WRITE-ARGS ...).

;;; Compiling (DEFUN FILTER-UNREADABLE-FORMS ...).

;;; Compiling (DEFMACRO DEF-RANDOM-WRITE-TEST-FUN ...).

;;; Compiling (DEFUN RANDOM-WRITE-TEST ...).

;;; Compiling (DEFUN RANDOM-PRIN1-TEST ...).

;;; Compiling (DEFUN RANDOM-PRINC-TEST ...).

;;; Compiling (DEFUN RANDOM-PRINT-TEST ...).

;;; Compiling (DEFUN RANDOM-PPRINT-TEST ...).

;;; Compiling (DEFMACRO DEF-RANDOM-WRITE-TO-STRING-TEST-FUN ...).

;;; Compiling (DEFUN RANDOM-WRITE-TO-STRING-TEST ...).

;;; Compiling (DEFUN RANDOM-PRIN1-TO-STRING-TEST ...).

;;; Compiling (DEFUN RANDOM-PRINC-TO-STRING-TEST ...).

;;; Compiling (DEFUN DECODE-FIXED-DECIMAL-STRING ...).

;;; Compiling (DEFMACRO DEF-FORMAT-TEST ...).

;;; Compiling (DEFMACRO FORMATTER-CALL-TO-STRING ...).

;;; End of Pass 1.

;;; Emitting code for DEF-PRINT-TEST.

;;; Emitting code for DEF-PPRINT-TEST.

;;; Emitting code for DEF-PPBLOCK-TEST.

;;; Emitting code for RANDOMLY-CHECK-READABILITY.

;;; Emitting code for %PARAMS.

;;; Emitting code for #:G27.

;;; Emitting code for #:G40.

;;; Emitting code for #:G41.

;;; Emitting code for #:G42.

;;; Emitting code for #:G43.

;;; Emitting code for PARSE-ESCAPED-STRING.

;;; Emitting code for #:G50.

;;; Emitting code for #:G51.

;;; Emitting code for #:G60.

;;; Emitting code for #:G61.

;;; Emitting code for #:G76.

;;; Emitting code for #:G77.

;;; Emitting code for ESCAPED-EQUAL.

;;; Emitting code for SIMILAR-UNINTERNED-SYMBOLS.

;;; Emitting code for MAKE-RANDOM-CONS-TREE.

;;; Emitting code for MAKE-RANDOM-VECTOR.

;;; Emitting code for FUNCALL-WITH-PRINT-BINDINGS.

;;; Emitting code for OUTPUT-TEST.

;;; Emitting code for #:G104.

;;; Emitting code for #:G105.

;;; Emitting code for #:G112.

;;; Emitting code for #:G113.

;;; Emitting code for MAKE-RANDOM-KEY-PARAM.

;;; Emitting code for MAKE-RANDOM-KEY-INTEGER-OR-NIL-PARAM.

;;; Emitting code for MAKE-RANDOM-WRITE-ARGS.

;;; Emitting code for FILTER-UNREADABLE-FORMS.

;;; Emitting code for DEF-RANDOM-WRITE-TEST-FUN.

;;; Emitting code for RANDOM-WRITE-TEST.

;;; Emitting code for RANDOM-PRIN1-TEST.

;;; Emitting code for RANDOM-PRINC-TEST.

;;; Emitting code for RANDOM-PRINT-TEST.

;;; Emitting code for RANDOM-PPRINT-TEST.

;;; Emitting code for #:G173.

;;; Emitting code for #:G182.

;;; Emitting code for #:G183.

;;; Emitting code for DEF-RANDOM-WRITE-TO-STRING-TEST-FUN.

;;; Emitting code for RANDOM-WRITE-TO-STRING-TEST.

;;; Emitting code for RANDOM-PRIN1-TO-STRING-TEST.

;;; Emitting code for #:G208.

;;; Emitting code for RANDOM-PRINC-TO-STRING-TEST.

;;; Emitting code for #:G219.

;;; Emitting code for DECODE-FIXED-DECIMAL-STRING.

;;; Emitting code for #:G227.

;;; Emitting code for #:G228.

;;; Emitting code for #:G236.

;;; Emitting code for #:G237.

;;; Emitting code for #:G245.

;;; Emitting code for #:G246.

;;; Emitting code for #:G253.

;;; Emitting code for #:G254.

;;; Emitting code for DEF-FORMAT-TEST.

;;; Emitting code for #:G293.

;;; Emitting code for #:G294.

;;; Emitting code for #:G302.

;;; Emitting code for #:G303.

;;; Emitting code for #:G310.

;;; Emitting code for #:G311.

;;; Emitting code for FORMATTER-CALL-TO-STRING.

printer-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/printer-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/printer-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/printer-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/printer-aux.fas" T NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/backquote-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFUN MAKE-RANDOM-BACKQUOTED-FORM ...).

;;; Compiling (DEFUN MAKE-RANDOM-BACKQUOTED-SEQUENCE-STRING ...).

;;; Compiling (DEFUN MAKE-RANDOM-BACKQUOTED-STRING ...).

;;; End of Pass 1.

;;; Emitting code for MAKE-RANDOM-BACKQUOTED-FORM.

;;; Emitting code for MAKE-RANDOM-BACKQUOTED-SEQUENCE-STRING.

;;; Emitting code for MAKE-RANDOM-BACKQUOTED-STRING.

backquote-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/backquote-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/backquote-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/backquote-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/backquote-aux.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/roman-numerals.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFPARAMETER *ROMAN-NUMERALS* ...).

;;; End of Pass 1.roman-numerals.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/roman-numerals.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/roman-numerals.exp


;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/roman-numerals.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/roman-numerals.fas" NIL NIL) 

;;; Compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/reader-aux.lsp.

;;; OPTIMIZE levels: Safety=3, Space=0, Speed=3, Debug=0

;;; Compiling (DEFMACRO DEF-SYNTAX-TEST ...).

;;; Compiling (DEFMACRO DEF-SYNTAX-VECTOR-TEST ...).

;;; Compiling (DEFMACRO DEF-SYNTAX-BIT-VECTOR-TEST ...).

;;; Compiling (DEFMACRO DEF-SYNTAX-UNINTERN-TEST ...).

;;; Compiling (DEFMACRO DEF-SYNTAX-ARRAY-TEST ...).

;;; End of Pass 1.

;;; Emitting code for DEF-SYNTAX-TEST.

;;; Emitting code for DEF-SYNTAX-VECTOR-TEST.

;;; Emitting code for DEF-SYNTAX-BIT-VECTOR-TEST.

;;; Emitting code for DEF-SYNTAX-UNINTERN-TEST.

;;; Emitting code for DEF-SYNTAX-ARRAY-TEST.

reader-aux.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/reader-aux.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/reader-aux.exp
;;; Finished compiling C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/reader-aux.lsp.



(#P"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/reader-aux.fas" NIL NIL) ;;; Warning: Redefining test |SET-SYNTAX-FROM-CHAR-TRAIT-X-NEWLINE|



Doing 21701 pending tests of 21701 tests total.

 SYMBOL-&ALLOW-OTHER-KEYS SYMBOL-&AUX SYMBOL-&BODY SYMBOL-&ENVIRONMENT

 SYMBOL-&KEY SYMBOL-&OPTIONAL SYMBOL-&REST SYMBOL-&WHOLE SYMBOL-*

 SYMBOL-** SYMBOL-*** SYMBOL-*BREAK-ON-SIGNALS*

 SYMBOL-*COMPILE-FILE-PATHNAME* SYMBOL-*COMPILE-FILE-TRUENAME*

 SYMBOL-*COMPILE-PRINT* SYMBOL-*COMPILE-VERBOSE* SYMBOL-*DEBUG-IO*

 SYMBOL-*DEBUGGER-HOOK* SYMBOL-*DEFAULT-PATHNAME-DEFAULTS*

 SYMBOL-*ERROR-OUTPUT* SYMBOL-*FEATURES* SYMBOL-*GENSYM-COUNTER*

 SYMBOL-*LOAD-PATHNAME* SYMBOL-*LOAD-PRINT* SYMBOL-*LOAD-TRUENAME*

 SYMBOL-*LOAD-VERBOSE* SYMBOL-*MACROEXPAND-HOOK* SYMBOL-*MODULES*

 SYMBOL-*PACKAGE* SYMBOL-*PRINT-ARRAY* SYMBOL-*PRINT-BASE*

 SYMBOL-*PRINT-CASE* SYMBOL-*PRINT-CIRCLE* SYMBOL-*PRINT-ESCAPE*

 SYMBOL-*PRINT-GENSYM* SYMBOL-*PRINT-LENGTH* SYMBOL-*PRINT-LEVEL*

 SYMBOL-*PRINT-LINES* SYMBOL-*PRINT-MISER-WIDTH*

 SYMBOL-*PRINT-PPRINT-DISPATCH* SYMBOL-*PRINT-PRETTY*

 SYMBOL-*PRINT-RADIX* SYMBOL-*PRINT-READABLY*

 SYMBOL-*PRINT-RIGHT-MARGIN* SYMBOL-*QUERY-IO* SYMBOL-*RANDOM-STATE*

 SYMBOL-*READ-BASE* SYMBOL-*READ-DEFAULT-FLOAT-FORMAT*

 SYMBOL-*READ-EVAL* SYMBOL-*READ-SUPPRESS* SYMBOL-*READTABLE*

 SYMBOL-*STANDARD-INPUT* SYMBOL-*STANDARD-OUTPUT* SYMBOL-*TERMINAL-IO*

 SYMBOL-*TRACE-OUTPUT* SYMBOL-+ SYMBOL-++ SYMBOL-+++ SYMBOL-- SYMBOL-/

 SYMBOL-// SYMBOL-/// SYMBOL-/= SYMBOL-1+ SYMBOL-1- SYMBOL-< SYMBOL-<=

 SYMBOL-= SYMBOL-> SYMBOL->= SYMBOL-ABORT SYMBOL-ABS SYMBOL-ACONS

 SYMBOL-ACOS SYMBOL-ACOSH SYMBOL-ADD-METHOD SYMBOL-ADJOIN

 SYMBOL-ADJUST-ARRAY SYMBOL-ADJUSTABLE-ARRAY-P SYMBOL-ALLOCATE-INSTANCE

 SYMBOL-ALPHA-CHAR-P SYMBOL-ALPHANUMERICP SYMBOL-AND SYMBOL-APPEND

 SYMBOL-APPLY SYMBOL-APROPOS SYMBOL-APROPOS-LIST SYMBOL-AREF

 SYMBOL-ARITHMETIC-ERROR SYMBOL-ARITHMETIC-ERROR-OPERANDS

 SYMBOL-ARITHMETIC-ERROR-OPERATION SYMBOL-ARRAY SYMBOL-ARRAY-DIMENSION

 SYMBOL-ARRAY-DIMENSION-LIMIT SYMBOL-ARRAY-DIMENSIONS

 SYMBOL-ARRAY-DISPLACEMENT SYMBOL-ARRAY-ELEMENT-TYPE

 SYMBOL-ARRAY-HAS-FILL-POINTER-P SYMBOL-ARRAY-IN-BOUNDS-P

 SYMBOL-ARRAY-RANK SYMBOL-ARRAY-RANK-LIMIT SYMBOL-ARRAY-ROW-MAJOR-INDEX

 SYMBOL-ARRAY-TOTAL-SIZE SYMBOL-ARRAY-TOTAL-SIZE-LIMIT SYMBOL-ARRAYP

 SYMBOL-ASH SYMBOL-ASIN SYMBOL-ASINH SYMBOL-ASSERT SYMBOL-ASSOC

 SYMBOL-ASSOC-IF SYMBOL-ASSOC-IF-NOT SYMBOL-ATAN SYMBOL-ATANH

 SYMBOL-ATOM SYMBOL-BASE-CHAR SYMBOL-BASE-STRING SYMBOL-BIGNUM

 SYMBOL-BIT SYMBOL-BIT-AND SYMBOL-BIT-ANDC1 SYMBOL-BIT-ANDC2

 SYMBOL-BIT-EQV SYMBOL-BIT-IOR SYMBOL-BIT-NAND SYMBOL-BIT-NOR

 SYMBOL-BIT-NOT SYMBOL-BIT-ORC1 SYMBOL-BIT-ORC2 SYMBOL-BIT-VECTOR

 SYMBOL-BIT-VECTOR-P SYMBOL-BIT-XOR SYMBOL-BLOCK SYMBOL-BOOLE

 SYMBOL-BOOLE-1 SYMBOL-BOOLE-2 SYMBOL-BOOLE-AND SYMBOL-BOOLE-ANDC1

 SYMBOL-BOOLE-ANDC2 SYMBOL-BOOLE-C1 SYMBOL-BOOLE-C2 SYMBOL-BOOLE-CLR

 SYMBOL-BOOLE-EQV SYMBOL-BOOLE-IOR SYMBOL-BOOLE-NAND SYMBOL-BOOLE-NOR

 SYMBOL-BOOLE-ORC1 SYMBOL-BOOLE-ORC2 SYMBOL-BOOLE-SET SYMBOL-BOOLE-XOR

 SYMBOL-BOOLEAN SYMBOL-BOTH-CASE-P SYMBOL-BOUNDP SYMBOL-BREAK

 SYMBOL-BROADCAST-STREAM SYMBOL-BROADCAST-STREAM-STREAMS

 SYMBOL-BUILT-IN-CLASS SYMBOL-BUTLAST SYMBOL-BYTE SYMBOL-BYTE-POSITION

 SYMBOL-BYTE-SIZE SYMBOL-CAAAAR SYMBOL-CAAADR SYMBOL-CAAAR SYMBOL-CAADAR

 SYMBOL-CAADDR SYMBOL-CAADR SYMBOL-CAAR SYMBOL-CADAAR SYMBOL-CADADR

 SYMBOL-CADAR SYMBOL-CADDAR SYMBOL-CADDDR SYMBOL-CADDR SYMBOL-CADR

 SYMBOL-CALL-ARGUMENTS-LIMIT SYMBOL-CALL-METHOD SYMBOL-CALL-NEXT-METHOD

 SYMBOL-CAR SYMBOL-CASE SYMBOL-CATCH SYMBOL-CCASE SYMBOL-CDAAAR

 SYMBOL-CDAADR SYMBOL-CDAAR SYMBOL-CDADAR SYMBOL-CDADDR SYMBOL-CDADR

 SYMBOL-CDAR SYMBOL-CDDAAR SYMBOL-CDDADR SYMBOL-CDDAR SYMBOL-CDDDAR

 SYMBOL-CDDDDR SYMBOL-CDDDR SYMBOL-CDDR SYMBOL-CDR SYMBOL-CEILING

 SYMBOL-CELL-ERROR SYMBOL-CELL-ERROR-NAME SYMBOL-CERROR

 SYMBOL-CHANGE-CLASS SYMBOL-CHAR SYMBOL-CHAR-CODE SYMBOL-CHAR-CODE-LIMIT

 SYMBOL-CHAR-DOWNCASE SYMBOL-CHAR-EQUAL SYMBOL-CHAR-GREATERP

 SYMBOL-CHAR-INT SYMBOL-CHAR-LESSP SYMBOL-CHAR-NAME

 SYMBOL-CHAR-NOT-EQUAL SYMBOL-CHAR-NOT-GREATERP SYMBOL-CHAR-NOT-LESSP

 SYMBOL-CHAR-UPCASE SYMBOL-CHAR/= SYMBOL-CHAR< SYMBOL-CHAR<=

 SYMBOL-CHAR= SYMBOL-CHAR> SYMBOL-CHAR>= SYMBOL-CHARACTER

 SYMBOL-CHARACTERP SYMBOL-CHECK-TYPE SYMBOL-CIS SYMBOL-CLASS

 SYMBOL-CLASS-NAME SYMBOL-CLASS-OF SYMBOL-CLEAR-INPUT

 SYMBOL-CLEAR-OUTPUT SYMBOL-CLOSE SYMBOL-CLRHASH SYMBOL-CODE-CHAR

 SYMBOL-COERCE SYMBOL-COMPILATION-SPEED SYMBOL-COMPILE

 SYMBOL-COMPILE-FILE SYMBOL-COMPILE-FILE-PATHNAME

 SYMBOL-COMPILED-FUNCTION SYMBOL-COMPILED-FUNCTION-P

 SYMBOL-COMPILER-MACRO SYMBOL-COMPILER-MACRO-FUNCTION SYMBOL-COMPLEMENT

 SYMBOL-COMPLEX SYMBOL-COMPLEXP SYMBOL-COMPUTE-APPLICABLE-METHODS

 SYMBOL-COMPUTE-RESTARTS SYMBOL-CONCATENATE SYMBOL-CONCATENATED-STREAM

 SYMBOL-CONCATENATED-STREAM-STREAMS SYMBOL-COND SYMBOL-CONDITION

 SYMBOL-CONJUGATE SYMBOL-CONS SYMBOL-CONSP SYMBOL-CONSTANTLY

 SYMBOL-CONSTANTP SYMBOL-CONTINUE SYMBOL-CONTROL-ERROR SYMBOL-COPY-ALIST

 SYMBOL-COPY-LIST SYMBOL-COPY-PPRINT-DISPATCH SYMBOL-COPY-READTABLE

 SYMBOL-COPY-SEQ SYMBOL-COPY-STRUCTURE SYMBOL-COPY-SYMBOL

 SYMBOL-COPY-TREE SYMBOL-COS SYMBOL-COSH SYMBOL-COUNT SYMBOL-COUNT-IF

 SYMBOL-COUNT-IF-NOT SYMBOL-CTYPECASE SYMBOL-DEBUG SYMBOL-DECF

 SYMBOL-DECLAIM SYMBOL-DECLARATION SYMBOL-DECLARE SYMBOL-DECODE-FLOAT

 SYMBOL-DECODE-UNIVERSAL-TIME SYMBOL-DEFCLASS SYMBOL-DEFCONSTANT

 SYMBOL-DEFGENERIC SYMBOL-DEFINE-COMPILER-MACRO SYMBOL-DEFINE-CONDITION

 SYMBOL-DEFINE-METHOD-COMBINATION SYMBOL-DEFINE-MODIFY-MACRO

 SYMBOL-DEFINE-SETF-EXPANDER SYMBOL-DEFINE-SYMBOL-MACRO SYMBOL-DEFMACRO

 SYMBOL-DEFMETHOD SYMBOL-DEFPACKAGE SYMBOL-DEFPARAMETER SYMBOL-DEFSETF

 SYMBOL-DEFSTRUCT SYMBOL-DEFTYPE SYMBOL-DEFUN SYMBOL-DEFVAR

 SYMBOL-DELETE SYMBOL-DELETE-DUPLICATES SYMBOL-DELETE-FILE

 SYMBOL-DELETE-IF SYMBOL-DELETE-IF-NOT SYMBOL-DELETE-PACKAGE

 SYMBOL-DENOMINATOR SYMBOL-DEPOSIT-FIELD SYMBOL-DESCRIBE

 SYMBOL-DESCRIBE-OBJECT SYMBOL-DESTRUCTURING-BIND SYMBOL-DIGIT-CHAR

 SYMBOL-DIGIT-CHAR-P SYMBOL-DIRECTORY SYMBOL-DIRECTORY-NAMESTRING

 SYMBOL-DISASSEMBLE SYMBOL-DIVISION-BY-ZERO SYMBOL-DO SYMBOL-DO*

 SYMBOL-DO-ALL-SYMBOLS SYMBOL-DO-EXTERNAL-SYMBOLS SYMBOL-DO-SYMBOLS

 SYMBOL-DOCUMENTATION SYMBOL-DOLIST SYMBOL-DOTIMES SYMBOL-DOUBLE-FLOAT

 SYMBOL-DOUBLE-FLOAT-EPSILON SYMBOL-DOUBLE-FLOAT-NEGATIVE-EPSILON

 SYMBOL-DPB SYMBOL-DRIBBLE SYMBOL-DYNAMIC-EXTENT SYMBOL-ECASE

 SYMBOL-ECHO-STREAM SYMBOL-ECHO-STREAM-INPUT-STREAM

 SYMBOL-ECHO-STREAM-OUTPUT-STREAM SYMBOL-ED SYMBOL-EIGHTH SYMBOL-ELT

 SYMBOL-ENCODE-UNIVERSAL-TIME SYMBOL-END-OF-FILE SYMBOL-ENDP

 SYMBOL-ENOUGH-NAMESTRING SYMBOL-ENSURE-DIRECTORIES-EXIST

 SYMBOL-ENSURE-GENERIC-FUNCTION SYMBOL-EQ SYMBOL-EQL SYMBOL-EQUAL

 SYMBOL-EQUALP SYMBOL-ERROR SYMBOL-ETYPECASE SYMBOL-EVAL

 SYMBOL-EVAL-WHEN SYMBOL-EVENP SYMBOL-EVERY SYMBOL-EXP SYMBOL-EXPORT

 SYMBOL-EXPT SYMBOL-EXTENDED-CHAR SYMBOL-FBOUNDP SYMBOL-FCEILING

 SYMBOL-FDEFINITION SYMBOL-FFLOOR SYMBOL-FIFTH SYMBOL-FILE-AUTHOR

 SYMBOL-FILE-ERROR SYMBOL-FILE-ERROR-PATHNAME SYMBOL-FILE-LENGTH

 SYMBOL-FILE-NAMESTRING SYMBOL-FILE-POSITION SYMBOL-FILE-STREAM

 SYMBOL-FILE-STRING-LENGTH SYMBOL-FILE-WRITE-DATE SYMBOL-FILL

 SYMBOL-FILL-POINTER SYMBOL-FIND SYMBOL-FIND-ALL-SYMBOLS

 SYMBOL-FIND-CLASS SYMBOL-FIND-IF SYMBOL-FIND-IF-NOT SYMBOL-FIND-METHOD

 SYMBOL-FIND-PACKAGE SYMBOL-FIND-RESTART SYMBOL-FIND-SYMBOL

 SYMBOL-FINISH-OUTPUT SYMBOL-FIRST SYMBOL-FIXNUM SYMBOL-FLET

 SYMBOL-FLOAT SYMBOL-FLOAT-DIGITS SYMBOL-FLOAT-PRECISION

 SYMBOL-FLOAT-RADIX SYMBOL-FLOAT-SIGN SYMBOL-FLOATING-POINT-INEXACT

 SYMBOL-FLOATING-POINT-INVALID-OPERATION SYMBOL-FLOATING-POINT-OVERFLOW

 SYMBOL-FLOATING-POINT-UNDERFLOW SYMBOL-FLOATP SYMBOL-FLOOR

 SYMBOL-FMAKUNBOUND SYMBOL-FORCE-OUTPUT SYMBOL-FORMAT SYMBOL-FORMATTER

 SYMBOL-FOURTH SYMBOL-FRESH-LINE SYMBOL-FROUND SYMBOL-FTRUNCATE

 SYMBOL-FTYPE SYMBOL-FUNCALL SYMBOL-FUNCTION SYMBOL-FUNCTION-KEYWORDS

 SYMBOL-FUNCTION-LAMBDA-EXPRESSION SYMBOL-FUNCTIONP SYMBOL-GCD

 SYMBOL-GENERIC-FUNCTION SYMBOL-GENSYM SYMBOL-GENTEMP SYMBOL-GET

 SYMBOL-GET-DECODED-TIME SYMBOL-GET-DISPATCH-MACRO-CHARACTER

 SYMBOL-GET-INTERNAL-REAL-TIME SYMBOL-GET-INTERNAL-RUN-TIME

 SYMBOL-GET-MACRO-CHARACTER SYMBOL-GET-OUTPUT-STREAM-STRING

 SYMBOL-GET-PROPERTIES SYMBOL-GET-SETF-EXPANSION

 SYMBOL-GET-UNIVERSAL-TIME SYMBOL-GETF SYMBOL-GETHASH SYMBOL-GO

 SYMBOL-GRAPHIC-CHAR-P SYMBOL-HANDLER-BIND SYMBOL-HANDLER-CASE

 SYMBOL-HASH-TABLE SYMBOL-HASH-TABLE-COUNT SYMBOL-HASH-TABLE-P

 SYMBOL-HASH-TABLE-REHASH-SIZE SYMBOL-HASH-TABLE-REHASH-THRESHOLD

 SYMBOL-HASH-TABLE-SIZE SYMBOL-HASH-TABLE-TEST SYMBOL-HOST-NAMESTRING

 SYMBOL-IDENTITY SYMBOL-IF SYMBOL-IGNORABLE SYMBOL-IGNORE

 SYMBOL-IGNORE-ERRORS SYMBOL-IMAGPART SYMBOL-IMPORT SYMBOL-IN-PACKAGE

 SYMBOL-INCF SYMBOL-INITIALIZE-INSTANCE SYMBOL-INLINE

 SYMBOL-INPUT-STREAM-P SYMBOL-INSPECT SYMBOL-INTEGER

 SYMBOL-INTEGER-DECODE-FLOAT SYMBOL-INTEGER-LENGTH SYMBOL-INTEGERP

 SYMBOL-INTERACTIVE-STREAM-P SYMBOL-INTERN

 SYMBOL-INTERNAL-TIME-UNITS-PER-SECOND SYMBOL-INTERSECTION

 SYMBOL-INVALID-METHOD-ERROR SYMBOL-INVOKE-DEBUGGER

 SYMBOL-INVOKE-RESTART SYMBOL-INVOKE-RESTART-INTERACTIVELY SYMBOL-ISQRT

 SYMBOL-KEYWORD SYMBOL-KEYWORDP SYMBOL-LABELS SYMBOL-LAMBDA

 SYMBOL-LAMBDA-LIST-KEYWORDS SYMBOL-LAMBDA-PARAMETERS-LIMIT SYMBOL-LAST

 SYMBOL-LCM SYMBOL-LDB SYMBOL-LDB-TEST SYMBOL-LDIFF

 SYMBOL-LEAST-NEGATIVE-DOUBLE-FLOAT SYMBOL-LEAST-NEGATIVE-LONG-FLOAT

 SYMBOL-LEAST-NEGATIVE-NORMALIZED-DOUBLE-FLOAT

 SYMBOL-LEAST-NEGATIVE-NORMALIZED-LONG-FLOAT

 SYMBOL-LEAST-NEGATIVE-NORMALIZED-SHORT-FLOAT

 SYMBOL-LEAST-NEGATIVE-NORMALIZED-SINGLE-FLOAT

 SYMBOL-LEAST-NEGATIVE-SHORT-FLOAT SYMBOL-LEAST-NEGATIVE-SINGLE-FLOAT

 SYMBOL-LEAST-POSITIVE-DOUBLE-FLOAT SYMBOL-LEAST-POSITIVE-LONG-FLOAT

 SYMBOL-LEAST-POSITIVE-NORMALIZED-DOUBLE-FLOAT

 SYMBOL-LEAST-POSITIVE-NORMALIZED-LONG-FLOAT

 SYMBOL-LEAST-POSITIVE-NORMALIZED-SHORT-FLOAT

 SYMBOL-LEAST-POSITIVE-NORMALIZED-SINGLE-FLOAT

 SYMBOL-LEAST-POSITIVE-SHORT-FLOAT SYMBOL-LEAST-POSITIVE-SINGLE-FLOAT

 SYMBOL-LENGTH SYMBOL-LET SYMBOL-LET* SYMBOL-LISP-IMPLEMENTATION-TYPE

 SYMBOL-LISP-IMPLEMENTATION-VERSION SYMBOL-LIST SYMBOL-LIST*

 SYMBOL-LIST-ALL-PACKAGES SYMBOL-LIST-LENGTH SYMBOL-LISTEN SYMBOL-LISTP

 SYMBOL-LOAD SYMBOL-LOAD-LOGICAL-PATHNAME-TRANSLATIONS

 SYMBOL-LOAD-TIME-VALUE SYMBOL-LOCALLY SYMBOL-LOG SYMBOL-LOGAND

 SYMBOL-LOGANDC1 SYMBOL-LOGANDC2 SYMBOL-LOGBITP SYMBOL-LOGCOUNT

 SYMBOL-LOGEQV SYMBOL-LOGICAL-PATHNAME

 SYMBOL-LOGICAL-PATHNAME-TRANSLATIONS SYMBOL-LOGIOR SYMBOL-LOGNAND

 SYMBOL-LOGNOR SYMBOL-LOGNOT SYMBOL-LOGORC1 SYMBOL-LOGORC2

 SYMBOL-LOGTEST SYMBOL-LOGXOR SYMBOL-LONG-FLOAT

 SYMBOL-LONG-FLOAT-EPSILON SYMBOL-LONG-FLOAT-NEGATIVE-EPSILON

 SYMBOL-LONG-SITE-NAME SYMBOL-LOOP SYMBOL-LOOP-FINISH

 SYMBOL-LOWER-CASE-P SYMBOL-MACHINE-INSTANCE SYMBOL-MACHINE-TYPE

 SYMBOL-MACHINE-VERSION SYMBOL-MACRO-FUNCTION SYMBOL-MACROEXPAND

 SYMBOL-MACROEXPAND-1 SYMBOL-MACROLET SYMBOL-MAKE-ARRAY

 SYMBOL-MAKE-BROADCAST-STREAM SYMBOL-MAKE-CONCATENATED-STREAM

 SYMBOL-MAKE-CONDITION SYMBOL-MAKE-DISPATCH-MACRO-CHARACTER

 SYMBOL-MAKE-ECHO-STREAM SYMBOL-MAKE-HASH-TABLE SYMBOL-MAKE-INSTANCE

 SYMBOL-MAKE-INSTANCES-OBSOLETE SYMBOL-MAKE-LIST SYMBOL-MAKE-LOAD-FORM

 SYMBOL-MAKE-LOAD-FORM-SAVING-SLOTS SYMBOL-MAKE-METHOD

 SYMBOL-MAKE-PACKAGE SYMBOL-MAKE-PATHNAME SYMBOL-MAKE-RANDOM-STATE

 SYMBOL-MAKE-SEQUENCE SYMBOL-MAKE-STRING SYMBOL-MAKE-STRING-INPUT-STREAM

 SYMBOL-MAKE-STRING-OUTPUT-STREAM SYMBOL-MAKE-SYMBOL

 SYMBOL-MAKE-SYNONYM-STREAM SYMBOL-MAKE-TWO-WAY-STREAM SYMBOL-MAKUNBOUND

 SYMBOL-MAP SYMBOL-MAP-INTO SYMBOL-MAPC SYMBOL-MAPCAN SYMBOL-MAPCAR

 SYMBOL-MAPCON SYMBOL-MAPHASH SYMBOL-MAPL SYMBOL-MAPLIST

 SYMBOL-MASK-FIELD SYMBOL-MAX SYMBOL-MEMBER SYMBOL-MEMBER-IF

 SYMBOL-MEMBER-IF-NOT SYMBOL-MERGE SYMBOL-MERGE-PATHNAMES SYMBOL-METHOD

 SYMBOL-METHOD-COMBINATION SYMBOL-METHOD-COMBINATION-ERROR

 SYMBOL-METHOD-QUALIFIERS SYMBOL-MIN SYMBOL-MINUSP SYMBOL-MISMATCH

 SYMBOL-MOD SYMBOL-MOST-NEGATIVE-DOUBLE-FLOAT

 SYMBOL-MOST-NEGATIVE-FIXNUM SYMBOL-MOST-NEGATIVE-LONG-FLOAT

 SYMBOL-MOST-NEGATIVE-SHORT-FLOAT SYMBOL-MOST-NEGATIVE-SINGLE-FLOAT

 SYMBOL-MOST-POSITIVE-DOUBLE-FLOAT SYMBOL-MOST-POSITIVE-FIXNUM

 SYMBOL-MOST-POSITIVE-LONG-FLOAT SYMBOL-MOST-POSITIVE-SHORT-FLOAT

 SYMBOL-MOST-POSITIVE-SINGLE-FLOAT SYMBOL-MUFFLE-WARNING

 SYMBOL-MULTIPLE-VALUE-BIND SYMBOL-MULTIPLE-VALUE-CALL

 SYMBOL-MULTIPLE-VALUE-LIST SYMBOL-MULTIPLE-VALUE-PROG1

 SYMBOL-MULTIPLE-VALUE-SETQ SYMBOL-MULTIPLE-VALUES-LIMIT

 SYMBOL-NAME-CHAR SYMBOL-NAMESTRING SYMBOL-NBUTLAST SYMBOL-NCONC

 SYMBOL-NEXT-METHOD-P SYMBOL-NIL SYMBOL-NINTERSECTION SYMBOL-NINTH

 SYMBOL-NO-APPLICABLE-METHOD SYMBOL-NO-NEXT-METHOD SYMBOL-NOT

 SYMBOL-NOTANY SYMBOL-NOTEVERY SYMBOL-NOTINLINE SYMBOL-NRECONC

 SYMBOL-NREVERSE SYMBOL-NSET-DIFFERENCE SYMBOL-NSET-EXCLUSIVE-OR

 SYMBOL-NSTRING-CAPITALIZE SYMBOL-NSTRING-DOWNCASE SYMBOL-NSTRING-UPCASE

 SYMBOL-NSUBLIS SYMBOL-NSUBST SYMBOL-NSUBST-IF SYMBOL-NSUBST-IF-NOT

 SYMBOL-NSUBSTITUTE SYMBOL-NSUBSTITUTE-IF SYMBOL-NSUBSTITUTE-IF-NOT

 SYMBOL-NTH SYMBOL-NTH-VALUE SYMBOL-NTHCDR SYMBOL-NULL SYMBOL-NUMBER

 SYMBOL-NUMBERP SYMBOL-NUMERATOR SYMBOL-NUNION SYMBOL-ODDP SYMBOL-OPEN

 SYMBOL-OPEN-STREAM-P SYMBOL-OPTIMIZE SYMBOL-OR SYMBOL-OTHERWISE

 SYMBOL-OUTPUT-STREAM-P SYMBOL-PACKAGE SYMBOL-PACKAGE-ERROR

 SYMBOL-PACKAGE-ERROR-PACKAGE SYMBOL-PACKAGE-NAME

 SYMBOL-PACKAGE-NICKNAMES SYMBOL-PACKAGE-SHADOWING-SYMBOLS

 SYMBOL-PACKAGE-USE-LIST SYMBOL-PACKAGE-USED-BY-LIST SYMBOL-PACKAGEP

 SYMBOL-PAIRLIS SYMBOL-PARSE-ERROR SYMBOL-PARSE-INTEGER

 SYMBOL-PARSE-NAMESTRING SYMBOL-PATHNAME SYMBOL-PATHNAME-DEVICE

 SYMBOL-PATHNAME-DIRECTORY SYMBOL-PATHNAME-HOST SYMBOL-PATHNAME-MATCH-P

 SYMBOL-PATHNAME-NAME SYMBOL-PATHNAME-TYPE SYMBOL-PATHNAME-VERSION

 SYMBOL-PATHNAMEP SYMBOL-PEEK-CHAR SYMBOL-PHASE SYMBOL-PI SYMBOL-PLUSP

 SYMBOL-POP SYMBOL-POSITION SYMBOL-POSITION-IF SYMBOL-POSITION-IF-NOT

 SYMBOL-PPRINT SYMBOL-PPRINT-DISPATCH

 SYMBOL-PPRINT-EXIT-IF-LIST-EXHAUSTED SYMBOL-PPRINT-FILL

 SYMBOL-PPRINT-INDENT SYMBOL-PPRINT-LINEAR SYMBOL-PPRINT-LOGICAL-BLOCK

 SYMBOL-PPRINT-NEWLINE SYMBOL-PPRINT-POP SYMBOL-PPRINT-TAB

 SYMBOL-PPRINT-TABULAR SYMBOL-PRIN1 SYMBOL-PRIN1-TO-STRING SYMBOL-PRINC

 SYMBOL-PRINC-TO-STRING SYMBOL-PRINT SYMBOL-PRINT-NOT-READABLE

 SYMBOL-PRINT-NOT-READABLE-OBJECT SYMBOL-PRINT-OBJECT

 SYMBOL-PRINT-UNREADABLE-OBJECT SYMBOL-PROBE-FILE SYMBOL-PROCLAIM

 SYMBOL-PROG SYMBOL-PROG* SYMBOL-PROG1 SYMBOL-PROG2 SYMBOL-PROGN

 SYMBOL-PROGRAM-ERROR SYMBOL-PROGV SYMBOL-PROVIDE SYMBOL-PSETF

 SYMBOL-PSETQ SYMBOL-PUSH SYMBOL-PUSHNEW SYMBOL-QUOTE SYMBOL-RANDOM

 SYMBOL-RANDOM-STATE SYMBOL-RANDOM-STATE-P SYMBOL-RASSOC

 SYMBOL-RASSOC-IF SYMBOL-RASSOC-IF-NOT SYMBOL-RATIO SYMBOL-RATIONAL

 SYMBOL-RATIONALIZE SYMBOL-RATIONALP SYMBOL-READ SYMBOL-READ-BYTE

 SYMBOL-READ-CHAR SYMBOL-READ-CHAR-NO-HANG SYMBOL-READ-DELIMITED-LIST

 SYMBOL-READ-FROM-STRING SYMBOL-READ-LINE

 SYMBOL-READ-PRESERVING-WHITESPACE SYMBOL-READ-SEQUENCE

 SYMBOL-READER-ERROR SYMBOL-READTABLE SYMBOL-READTABLE-CASE

 SYMBOL-READTABLEP SYMBOL-REAL SYMBOL-REALP SYMBOL-REALPART

 SYMBOL-REDUCE SYMBOL-REINITIALIZE-INSTANCE SYMBOL-REM SYMBOL-REMF

 SYMBOL-REMHASH SYMBOL-REMOVE SYMBOL-REMOVE-DUPLICATES SYMBOL-REMOVE-IF

 SYMBOL-REMOVE-IF-NOT SYMBOL-REMOVE-METHOD SYMBOL-REMPROP

 SYMBOL-RENAME-FILE SYMBOL-RENAME-PACKAGE SYMBOL-REPLACE SYMBOL-REQUIRE

 SYMBOL-REST SYMBOL-RESTART SYMBOL-RESTART-BIND SYMBOL-RESTART-CASE

 SYMBOL-RESTART-NAME SYMBOL-RETURN SYMBOL-RETURN-FROM SYMBOL-REVAPPEND

 SYMBOL-REVERSE SYMBOL-ROOM SYMBOL-ROTATEF SYMBOL-ROUND

 SYMBOL-ROW-MAJOR-AREF SYMBOL-RPLACA SYMBOL-RPLACD SYMBOL-SAFETY

 SYMBOL-SATISFIES SYMBOL-SBIT SYMBOL-SCALE-FLOAT SYMBOL-SCHAR

 SYMBOL-SEARCH SYMBOL-SECOND SYMBOL-SEQUENCE SYMBOL-SERIOUS-CONDITION

 SYMBOL-SET SYMBOL-SET-DIFFERENCE SYMBOL-SET-DISPATCH-MACRO-CHARACTER

 SYMBOL-SET-EXCLUSIVE-OR SYMBOL-SET-MACRO-CHARACTER

 SYMBOL-SET-PPRINT-DISPATCH SYMBOL-SET-SYNTAX-FROM-CHAR SYMBOL-SETF

 SYMBOL-SETQ SYMBOL-SEVENTH SYMBOL-SHADOW SYMBOL-SHADOWING-IMPORT

 SYMBOL-SHARED-INITIALIZE SYMBOL-SHIFTF SYMBOL-SHORT-FLOAT

 SYMBOL-SHORT-FLOAT-EPSILON SYMBOL-SHORT-FLOAT-NEGATIVE-EPSILON

 SYMBOL-SHORT-SITE-NAME SYMBOL-SIGNAL SYMBOL-SIGNED-BYTE SYMBOL-SIGNUM

 SYMBOL-SIMPLE-ARRAY SYMBOL-SIMPLE-BASE-STRING SYMBOL-SIMPLE-BIT-VECTOR

 SYMBOL-SIMPLE-BIT-VECTOR-P SYMBOL-SIMPLE-CONDITION

 SYMBOL-SIMPLE-CONDITION-FORMAT-ARGUMENTS

 SYMBOL-SIMPLE-CONDITION-FORMAT-CONTROL SYMBOL-SIMPLE-ERROR

 SYMBOL-SIMPLE-STRING SYMBOL-SIMPLE-STRING-P SYMBOL-SIMPLE-TYPE-ERROR

 SYMBOL-SIMPLE-VECTOR SYMBOL-SIMPLE-VECTOR-P SYMBOL-SIMPLE-WARNING

 SYMBOL-SIN SYMBOL-SINGLE-FLOAT SYMBOL-SINGLE-FLOAT-EPSILON

 SYMBOL-SINGLE-FLOAT-NEGATIVE-EPSILON SYMBOL-SINH SYMBOL-SIXTH

 SYMBOL-SLEEP SYMBOL-SLOT-BOUNDP SYMBOL-SLOT-EXISTS-P

 SYMBOL-SLOT-MAKUNBOUND SYMBOL-SLOT-MISSING SYMBOL-SLOT-UNBOUND

 SYMBOL-SLOT-VALUE SYMBOL-SOFTWARE-TYPE SYMBOL-SOFTWARE-VERSION

 SYMBOL-SOME SYMBOL-SORT SYMBOL-SPACE SYMBOL-SPECIAL

 SYMBOL-SPECIAL-OPERATOR-P SYMBOL-SPEED SYMBOL-SQRT SYMBOL-STABLE-SORT

 SYMBOL-STANDARD SYMBOL-STANDARD-CHAR SYMBOL-STANDARD-CHAR-P

 SYMBOL-STANDARD-CLASS SYMBOL-STANDARD-GENERIC-FUNCTION

 SYMBOL-STANDARD-METHOD SYMBOL-STANDARD-OBJECT SYMBOL-STEP

 SYMBOL-STORAGE-CONDITION SYMBOL-STORE-VALUE SYMBOL-STREAM

 SYMBOL-STREAM-ELEMENT-TYPE SYMBOL-STREAM-ERROR

 SYMBOL-STREAM-ERROR-STREAM SYMBOL-STREAM-EXTERNAL-FORMAT SYMBOL-STREAMP

 SYMBOL-STRING SYMBOL-STRING-CAPITALIZE SYMBOL-STRING-DOWNCASE

 SYMBOL-STRING-EQUAL SYMBOL-STRING-GREATERP SYMBOL-STRING-LEFT-TRIM

 SYMBOL-STRING-LESSP SYMBOL-STRING-NOT-EQUAL SYMBOL-STRING-NOT-GREATERP

 SYMBOL-STRING-NOT-LESSP SYMBOL-STRING-RIGHT-TRIM SYMBOL-STRING-STREAM

 SYMBOL-STRING-TRIM SYMBOL-STRING-UPCASE SYMBOL-STRING/= SYMBOL-STRING<

 SYMBOL-STRING<= SYMBOL-STRING= SYMBOL-STRING> SYMBOL-STRING>=

 SYMBOL-STRINGP SYMBOL-STRUCTURE SYMBOL-STRUCTURE-CLASS

 SYMBOL-STRUCTURE-OBJECT SYMBOL-STYLE-WARNING SYMBOL-SUBLIS

 SYMBOL-SUBSEQ SYMBOL-SUBSETP SYMBOL-SUBST SYMBOL-SUBST-IF

 SYMBOL-SUBST-IF-NOT SYMBOL-SUBSTITUTE SYMBOL-SUBSTITUTE-IF

 SYMBOL-SUBSTITUTE-IF-NOT SYMBOL-SUBTYPEP SYMBOL-SVREF SYMBOL-SXHASH

 SYMBOL-SYMBOL SYMBOL-SYMBOL-FUNCTION SYMBOL-SYMBOL-MACROLET

 SYMBOL-SYMBOL-NAME SYMBOL-SYMBOL-PACKAGE SYMBOL-SYMBOL-PLIST

 SYMBOL-SYMBOL-VALUE SYMBOL-SYMBOLP SYMBOL-SYNONYM-STREAM

 SYMBOL-SYNONYM-STREAM-SYMBOL SYMBOL-T SYMBOL-TAGBODY SYMBOL-TAILP

 SYMBOL-TAN SYMBOL-TANH SYMBOL-TENTH SYMBOL-TERPRI SYMBOL-THE

 SYMBOL-THIRD SYMBOL-THROW SYMBOL-TIME SYMBOL-TRACE

 SYMBOL-TRANSLATE-LOGICAL-PATHNAME SYMBOL-TRANSLATE-PATHNAME

 SYMBOL-TREE-EQUAL SYMBOL-TRUENAME SYMBOL-TRUNCATE SYMBOL-TWO-WAY-STREAM

 SYMBOL-TWO-WAY-STREAM-INPUT-STREAM SYMBOL-TWO-WAY-STREAM-OUTPUT-STREAM

 SYMBOL-TYPE SYMBOL-TYPE-ERROR SYMBOL-TYPE-ERROR-DATUM

 SYMBOL-TYPE-ERROR-EXPECTED-TYPE SYMBOL-TYPE-OF SYMBOL-TYPECASE

 SYMBOL-TYPEP SYMBOL-UNBOUND-SLOT SYMBOL-UNBOUND-SLOT-INSTANCE

 SYMBOL-UNBOUND-VARIABLE SYMBOL-UNDEFINED-FUNCTION SYMBOL-UNEXPORT

 SYMBOL-UNINTERN SYMBOL-UNION SYMBOL-UNLESS SYMBOL-UNREAD-CHAR

 SYMBOL-UNSIGNED-BYTE SYMBOL-UNTRACE SYMBOL-UNUSE-PACKAGE

 SYMBOL-UNWIND-PROTECT SYMBOL-UPDATE-INSTANCE-FOR-DIFFERENT-CLASS

 SYMBOL-UPDATE-INSTANCE-FOR-REDEFINED-CLASS

 SYMBOL-UPGRADED-ARRAY-ELEMENT-TYPE SYMBOL-UPGRADED-COMPLEX-PART-TYPE

 SYMBOL-UPPER-CASE-P SYMBOL-USE-PACKAGE SYMBOL-USE-VALUE

 SYMBOL-USER-HOMEDIR-PATHNAME SYMBOL-VALUES SYMBOL-VALUES-LIST

 SYMBOL-VARIABLE SYMBOL-VECTOR SYMBOL-VECTOR-POP SYMBOL-VECTOR-PUSH

 SYMBOL-VECTOR-PUSH-EXTEND SYMBOL-VECTORP SYMBOL-WARN SYMBOL-WARNING

 SYMBOL-WHEN SYMBOL-WILD-PATHNAME-P SYMBOL-WITH-ACCESSORS

 SYMBOL-WITH-COMPILATION-UNIT SYMBOL-WITH-CONDITION-RESTARTS

 SYMBOL-WITH-HASH-TABLE-ITERATOR SYMBOL-WITH-INPUT-FROM-STRING

 SYMBOL-WITH-OPEN-FILE SYMBOL-WITH-OPEN-STREAM

 SYMBOL-WITH-OUTPUT-TO-STRING SYMBOL-WITH-PACKAGE-ITERATOR

 SYMBOL-WITH-SIMPLE-RESTART SYMBOL-WITH-SLOTS

 SYMBOL-WITH-STANDARD-IO-SYNTAX SYMBOL-WRITE SYMBOL-WRITE-BYTE

 SYMBOL-WRITE-CHAR SYMBOL-WRITE-LINE SYMBOL-WRITE-SEQUENCE

 SYMBOL-WRITE-STRING SYMBOL-WRITE-TO-STRING SYMBOL-Y-OR-N-P

 SYMBOL-YES-OR-NO-P SYMBOL-ZEROP KEYWORD-PACKAGE-NICKNAMES

Test COMMON-LISP-PACKAGE-NICKNAMES failed

Form: (PACKAGE-NICKNAMES (FIND-PACKAGE "COMMON-LISP"))

Expected value: ("CL")

Actual value: ("LISP" "CL").

Test COMMON-LISP-USER-PACKAGE-NICKNAMES failed

Form: (PACKAGE-NICKNAMES (FIND-PACKAGE "COMMON-LISP-USER"))

Expected value: ("CL-USER")

Actual value: ("USER" "CL-USER").

 NO-EXTRA-SYMBOLS-EXPORTED-FROM-COMMON-LISP KEYWORD-BEHAVIOR

 CL-FUNCTION-SYMBOLS.1 CL-MACRO-SYMBOLS.1 CL-CONSTANT-SYMBOLS.1

 CL-VARIABLE-SYMBOLS.1 CL-TYPES-THAT-ARE-CLASSES.1

 CL-TYPES-THAT-ARE-CLASSES.2 CL-TYPES-THAT-ARE-CLASSES.3

 SYMBOL-PACKAGE.ERROR.1 SYMBOL-PACKAGE.ERROR.2 SYMBOL-PACKAGE.ERROR.3

 SYMBOL-PLIST.ERROR.1 SYMBOL-PLIST.ERROR.2 SYMBOL-PLIST.ERROR.3

 SYMBOL-PLIST.ERROR.4 SYMBOL-VALUE.ERROR.1 SYMBOL-VALUE.ERROR.2

 SYMBOL-VALUE.ERROR.3 SYMBOL-VALUE.ERROR.4 SYMBOL-VALUE.ERROR.5

 SYMBOLP.1 SYMBOLP.2 SYMBOLP.3 SYMBOLP.ERROR.1 SYMBOLP.ERROR.2

 KEYWORDP.1 KEYWORDP.2 KEYWORDP.3 KEYWORDP.4 KEYWORDP.5 KEYWORDP.6

 KEYWORDP.7 KEYWORDP.8 KEYWORDP.9 KEYWORDP.10 KEYWORDP.12 KEYWORDP.13

 KEYWORDP.ORDER.1 KEYWORDP.ERROR.1 KEYWORDP.ERROR.2 MAKE-SYMBOL.1

 MAKE-SYMBOL.2 MAKE-SYMBOL.3 MAKE-SYMBOL.4 MAKE-SYMBOL.5 MAKE-SYMBOL.6

 MAKE-SYMBOL.7 MAKE-SYMBOL.8 MAKE-SYMBOL.9 MAKE-SYMBOL.10 MAKE-SYMBOL.12

 MAKE-SYMBOL.13 MAKE-SYMBOL.14 MAKE-SYMBOL.15 MAKE-SYMBOL.16

 MAKE-SYMBOL.ORDER.1 MAKE-SYMBOL.ERROR.1 MAKE-SYMBOL.ERROR.9

 MAKE-SYMBOL.ERROR.10 MAKE-SYMBOL.ERROR.11 COPY-SYMBOL.1 COPY-SYMBOL.2

 COPY-SYMBOL.3 COPY-SYMBOL.4 COPY-SYMBOL.5 COPY-SYMBOL.ERROR.1

 COPY-SYMBOL.ERROR.2 GENSYM.1 GENSYM.2 GENSYM.3 GENSYM.4 GENSYM.5

 GENSYM.6 GENSYM.7 GENSYM.8 GENSYM.9 GENSYM.10 GENSYM.11 GENSYM.12

 GENSYM.13 GENSYM-COUNTER.1 GENSYM.ERROR.1 GENSYM.ERROR.7 GENSYM.ERROR.8

 GENSYM.ERROR.9 GENTEMP.1 GENTEMP.2 GENTEMP.3 GENTEMP.4 GENTEMP.5

 GENTEMP.6 GENTEMP.ERROR.1 GENTEMP.ERROR.2 GENTEMP.ERROR.3

 SYMBOL-FUNCTION.1 SYMBOL-FUNCTION.ERROR.1 SYMBOL-FUNCTION.ERROR.2

 SYMBOL-FUNCTION.ERROR.3 SYMBOL-FUNCTION.ERROR.4 SYMBOL-FUNCTION.ERROR.5

 SYMBOL-NAME.1 SYMBOL-NAME.2 SYMBOL-NAME.3 SYMBOL-NAME.ERROR.1

 SYMBOL-NAME.ERROR.2 SYMBOL-NAME.ERROR.3 BOUNDP.ERROR.1 BOUNDP.ERROR.2

 BOUNDP.ERROR.3 BOUNDP.ERROR.4 BOUNDP.ERROR.5 BOUNDP.ERROR.6 BOUNDP.1

 BOUNDP.2 BOUNDP.3 BOUNDP.4

Test BOUNDP.5 failed

Form: (LOOP FOR

            X

            IN

            *CL-NON-VARIABLE-CONSTANT-SYMBOLS*

            WHEN

            (BOUNDP X)

            COLLECT

            X)

Expected value: NIL

Actual value: (FUNCTION).

 BOUNDP.6 BOUNDP.ORDER.1 SPECIAL-OPERATOR-P.1 SPECIAL-OPERATOR-P.2

 SPECIAL-OPERATOR-P.ORDER.1 SPECIAL-OPERATOR-P.ERROR.1

 SPECIAL-OPERATOR-P.ERROR.2 SPECIAL-OPERATOR-P.ERROR.3 MAKUNBOUND.1

 MAKUNBOUND.2 MAKUNBOUND.ERROR.1 MAKUNBOUND.ERROR.2 MAKUNBOUND.ERROR.3

 SET.1 SET.2 SET.ERROR.1 SET.ERROR.2 SET.ERROR.3 SET.ERROR.4 REMPROP.1

 REMPROP.2 REMPROP.3 REMPROP.4 REMPROP.ERROR.1 REMPROP.ERROR.2

 REMPROP.ERROR.3 REMPROP.ERROR.4 GET.1 GET.2 GET.3 GET.4 GET.5 GET.6

 GET.ORDER.1 GET.ORDER.2 GET.ORDER.3 GET.ORDER.4 GET.ERROR.1 GET.ERROR.2

 GET.ERROR.3 GET.ERROR.4 GET.ERROR.5 EVAL.1 EVAL.2 EVAL.3 EVAL.4 EVAL.5

 EVAL.6 EVAL.ORDER.1 EVAL.ERROR.1 EVAL.ERROR.2 EVAL.ERROR.3 EVAL.ERROR.4

 EVAL-AND-COMPILE-FNS EVAL-AND-COMPILE-MACROSEFF59.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF59.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF59.exp
 COMPILE.1EFF5C.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF5C.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF5C.exp
 COMPILE.2EFF5F.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF5F.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF5F.exp


 COMPILE.3EFF62.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF62.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF62.exp
 COMPILE.4EFF65.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF65.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF65.exp
 COMPILE.5EFF68.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF68.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF68.exp
 COMPILE.6EFF6B.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF6B.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF6B.exp
 COMPILE.7EFF6E.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF6E.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF6E.exp
 COMPILE.8EFF71.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF71.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF71.exp
 COMPILE.9

 COMPILE.ERROR.1 COMPILE.ERROR.2 CONSTANTP.ERROR.1 CONSTANTP.ERROR.2

 CONSTANTP.1 CONSTANTP.2 CONSTANTP.3 CONSTANTP.4 CONSTANTP.5 CONSTANTP.6

 CONSTANTP.7 CONSTANTP.8 CONSTANTP.9 CONSTANTP.10 CONSTANTP.11

 CONSTANTP.ORDER.1 CONSTANTP.ORDER.2 LAMBDA.1 LAMBDA.2 LAMBDA.3 LAMBDA.4

 LAMBDA.5 LAMBDA.6 LAMBDA.7 LAMBDA.8 LAMBDA.9 LAMBDA.10 LAMBDA.11

 LAMBDA.12 LAMBDA.13 LAMBDA.14 LAMBDA.15 LAMBDA.16 LAMBDA.17 LAMBDA.18

 LAMBDA.19 LAMBDA.20 LAMBDA.21 LAMBDA.22 LAMBDA.23 LAMBDA.24 LAMBDA.25

 LAMBDA.26 LAMBDA.27 LAMBDA.28 LAMBDA.29 LAMBDA.30 LAMBDA.31 LAMBDA.32

 LAMBDA.33 LAMBDA.34 LAMBDA.35 LAMBDA.36 LAMBDA.37 LAMBDA.38 LAMBDA.39

 LAMBDA.40 LAMBDA.41 LAMBDA.42 LAMBDA.43 LAMBDA.44 LAMBDA.45 LAMBDA.46

 LAMBDA.47 LAMBDA.48 LAMBDA.49 LAMBDA.50 LAMBDA.51 LAMBDA.52 LAMBDA.53

 LAMBDA.54EFF74.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF74.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF74.exp
 LAMBDA.55EFF77.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF77.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF77.exp
 LAMBDA.56 LAMBDA.57 LAMBDA.58 LAMBDA.59 LAMBDA.60

 LAMBDA.61 LAMBDA.62 LAMBDA.63 LAMBDA.64 LAMBDA.MACRO.1 LAMBDA.MACRO.2

 LAMBDA.ERROR.1 LAMBDA.ERROR.2 LAMBDA.ERROR.3generated-eval-when-test-file.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/generated-eval-when-test-file.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/generated-eval-when-test-file.exp
 EVAL-WHEN.1 EVAL-WHEN.2

 EVAL-WHEN.3 EVAL-WHEN.4 EVAL-WHEN.5 EVAL-WHEN.6 EVAL-WHEN.7 EVAL-WHEN.8

 EVAL-WHEN.9 EVAL-WHEN.10 EVAL-WHEN.11 EVAL-WHEN.12 EVAL-WHEN.13

 EVAL-WHEN.14 EVAL-WHEN.15 EVAL-WHEN.16 EVAL-WHEN.17 EVAL-WHEN.18

 DEFINE-COMPILER-MACRO.ERROR.1 DEFINE-COMPILER-MACRO.ERROR.2

 DEFINE-COMPILER-MACRO.ERROR.3EFF7C.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF7C.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF7C.exp
 DEFINE-COMPILER-MACRO.1EFF7F.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF7F.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF7F.exp


 DEFINE-COMPILER-MACRO.2EFF82.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF82.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF82.exp
 DEFINE-COMPILER-MACRO.3EFF85.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF85.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF85.exp
 DEFINE-COMPILER-MACRO.4

 DEFINE-COMPILER-MACRO.5 DEFINE-COMPILER-MACRO.6EFF88.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF88.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF88.exp
EFF8B.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF8B.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF8B.exp
 DEFINE-COMPILER-MACRO.7EFF8E.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF8E.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF8E.exp


 DEFINE-COMPILER-MACRO.8 DEFINE-SYMBOL-MACRO.ERROR.1

 DEFINE-SYMBOL-MACRO.ERROR.2 DEFINE-SYMBOL-MACRO.ERROR.3

 DEFMACRO.ERROR.1 DEFMACRO.ERROR.2 DEFMACRO.ERROR.3 DEFMACRO.1

 DEFMACRO.2 DEFMACRO.3 DEFMACRO.4 DEFMACRO.5 DEFMACRO.6 DEFMACRO.7

 DEFMACRO.8 DEFMACRO.9 DEFMACRO.10 DEFMACRO.11 DEFMACRO.12 DEFMACRO.13

 DEFMACRO.14 DEFMACRO.15 DEFMACRO.16 DEFMACRO.17 DEFMACRO.17A

 DEFMACRO.18 DEFMACRO.19 DEFMACRO.20 DEFMACRO.21 THE.1 THE.2 THE.3 THE.4

 THE.5 THE.6 THE.7 THE.8 THE.9 THE.10 THE.11EFF91.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF91.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF91.exp
 THE.12 THE.13 THE.14 THE.15

 THE.16 THE.17 THE.18 THE.19 THE.20 THE.21 THE.22 THE.23 THE.24 THE.25

 SYMBOL-MACROLET.1 SYMBOL-MACROLET.2 SYMBOL-MACROLET.3 SYMBOL-MACROLET.4

 SYMBOL-MACROLET.5 SYMBOL-MACROLET.6 SYMBOL-MACROLET.7 SYMBOL-MACROLET.8

 SYMBOL-MACROLET.ERROR.1 SYMBOL-MACROLET.ERROR.2 SYMBOL-MACROLET.ERROR.3

 SYMBOL-MACROLET.9 PROCLAIM.1 PROCLAIM.2 PROCLAIM.3 PROCLAIM.ERROR.1

 PROCLAIM.ERROR.2 PROCLAIM.ERROR.3 PROCLAIM.ERROR.4 PROCLAIM.ERROR.5

 PROCLAIM.ERROR.6

Test PROCLAIM.ERROR.7 failed

Form: (SIGNALS-ERROR (PROCLAIM (SI:QUASIQUOTE (FTYPE . FOO))) TYPE-ERROR)

Expected value: T

Actual value: #<a SIMPLE-ERROR>.

 PROCLAIM.ERROR.8 PROCLAIM.ERROR.9 PROCLAIM.ERROR.10 PROCLAIM.ERROR.11

 DECLAIM.1 DECLAIM.2 DECLAIM.3 DECLAIM.4 DECLAIM.5 DECLAIM.6 DECLAIM.7

 DECLAIM.8 DECLAIM.9 DECLAIM.10 DECLAIM.11 LOCALLY.1 LOCALLY.2 LOCALLY.3

 LOCALLY.4 LOCALLY.5 LOCALLY.6 LOCALLY.7 LOCALLY.8 IGNORE.1 IGNORE.2

 IGNORE.3 IGNORE.4 IGNORE.5 IGNORE.6 IGNORABLE.1 IGNORABLE.2 IGNORABLE.3

 IGNORABLE.4 IGNORABLE.5 IGNORABLE.6 IGNORABLE.7 IGNORABLE.8

 DYNAMIC-EXTENT.1 DYNAMIC-EXTENT.2 DYNAMIC-EXTENT.3 DYNAMIC-EXTENT.4

 DYNAMIC-EXTENT.5 DYNAMIC-EXTENT.6 DYNAMIC-EXTENT.7 DYNAMIC-EXTENT.8

 DYNAMIC-EXTENT.9 DYNAMIC-EXTENT.10 DYNAMIC-EXTENT.11EFF94.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF94.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF94.exp
EFF97.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF97.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF97.exp
EFF9A.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF9A.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF9A.exp
EFF9D.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF9D.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFF9D.exp
EFFA0.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA0.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA0.exp
EFFA3.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA3.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA3.exp
EFFA6.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA6.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA6.exp
EFFA9.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA9.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFA9.exp
EFFAC.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFAC.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFAC.exp
EFFAF.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFAF.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFAF.exp
EFFB2.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFB2.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFB2.exp
EFFB5.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFB5.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFB5.exp
EFFB8.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFB8.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFB8.exp
EFFBB.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFBB.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFBB.exp
EFFBE.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFBE.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFBE.exp
EFFC1.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFC1.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFC1.exp
EFFC4.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFC4.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFC4.exp
EFFC7.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFC7.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFC7.exp
EFFCA.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFCA.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFCA.exp
EFFCD.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFCD.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFCD.exp
EFFD0.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD0.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD0.exp
EFFD3.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD3.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD3.exp
EFFD6.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD6.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD6.exp
EFFD9.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD9.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFD9.exp
EFFDC.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFDC.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFDC.exp
EFFDF.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFDF.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFDF.exp
EFFE2.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFE2.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFE2.exp
EFFE5.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFE5.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFE5.exp
EFFE8.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFE8.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFE8.exp
EFFEB.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFEB.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFEB.exp
EFFEE.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFEE.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFEE.exp
EFFF1.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFF1.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFF1.exp
 DYNAMIC-EXTENT.12

 DYNAMIC-EXTENT.13 DYNAMIC-EXTENT.14 DYNAMIC-EXTENT.15 DYNAMIC-EXTENT.16

 OPTIMIZE.1 OPTIMIZE.2 OPTIMIZE.3 OPTIMIZE.4 OPTIMIZE.5 OPTIMIZE.6

 OPTIMIZE.7EFFF4.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFF4.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFF4.exp
EFFF7.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFF7.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFF7.exp
EFFFA.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFFA.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFFA.exp
EFFFD.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFFD.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EFFFD.exp
E1.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E1.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E1.exp
E4.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E4.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E4.exp
E7.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E7.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E7.exp
EA.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA.exp
ED.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/ED.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/ED.exp
E10.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E10.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E10.exp
E13.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E13.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E13.exp
E16.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E16.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E16.exp
E19.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E19.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E19.exp
E1C.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E1C.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E1C.exp
E1F.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E1F.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E1F.exp
E22.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E22.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E22.exp
E25.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E25.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E25.exp
E28.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E28.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E28.exp
E2B.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E2B.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E2B.exp
E2E.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E2E.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E2E.exp
 OPTIMIZE.8 SPECIAL.1 SPECIAL.2 SPECIAL.3 MACROEXPAND.ERROR.1

 MACROEXPAND.ERROR.2 MACROEXPAND.1 MACROEXPAND.2 MACROEXPAND.3

 MACROEXPAND.4 MACROEXPAND.5 MACROEXPAND.6 MACROEXPAND-1.ERROR.1

 MACROEXPAND-1.ERROR.2 MACROEXPAND-1.1 MACROEXPAND-1.2 MACROEXPAND-1.3

 MACROEXPAND-1.4 MACROEXPAND-1.5 MACROEXPAND-1.6 DECLARATION.1

 DECLARATION.2 DECLARATION.3 TYPE.1 TYPE.2 TYPE.3 TYPE.4 TYPE.5 TYPE.6

 MACRO-FUNCTION.1 MACRO-FUNCTION.2 MACRO-FUNCTION.3 MACRO-FUNCTION.4

 MACRO-FUNCTION.5 MACRO-FUNCTION.6 MACRO-FUNCTION.7 MACRO-FUNCTION.8

 MACRO-FUNCTION.9 MACRO-FUNCTION.10 MACRO-FUNCTION.11 MACRO-FUNCTION.12

 MACRO-FUNCTION.13 MACRO-FUNCTION.14 MACRO-FUNCTION.15

 MACRO-FUNCTION.ERROR.1 MACRO-FUNCTION.ERROR.2 DCF-FUNS DCF-MACROS

 SETF.ORDER.1 SETF.ORDER.2 INCF.ORDER.1 DECF.ORDER.1 SETF-VAR

 SETF-VALUES.1 SETF-VALUES.2 SETF-VALUES.3 SETF-VALUES.4 SETF-VALUES.5

 SETF-VALUES.6 SETF-THE.1 SETF-THE.2 SETF-APPLY.1 SETF-APPLY.2

 SETF-APPLY.3 SETF-APPLY.4 SETF-EXPANDER.1 SETF-MACRO.1 SETF-MACRO.2

 SETF-MACRO.3 SETF-MACRO.4 SETF-SYMBOL-MACRO.1 SETF-SYMBOL-MACRO.2

 SETF-SYMBOL-MACRO.3 SETQ.1 SETQ.2 SETQ.3 SETQ.4 SETQ.5 SETQ.6 SETQ.7

 SETF.1 SETF.2 SETF.3 SETF.4 SETF.5 SETF.6 SETF.7 SETF.8 PSETQ.1 PSETQ.2

 PSETQ.3 PSETQ.4 PSETQ.5 PSETQ.6 PSETQ.7 PSETQ.8 PSETQ.9 PSETQ.10

 PSETQ.ERROR.1 PSETQ.ERROR.2 PSETQ.ERROR.3 PSETF.ORDER.1 PSETF.ORDER.2

 PSETF.1 PSETF.2 PSETF.3 PSETF.4 PSETF.5 PSETF.6 PSETF.7 PSETF.8 PSETF.9

 PSETF.10 PSETF.11 PSETF.ERROR.1 PSETF.12 PSETF.12A PSETF.13 PSETF.13A

 PSETF.14 PSETF.15 PSETF.16 PSETF.17 PSETF.18 PSETF.18A PSETF.19

 PSETF.20 PSETF.21 PSETF.22 PSETF.23 PSETF.24 PSETF.25 PSETF.26 PSETF.27

 PSETF.28 PSETF.29 PSETF.30 PSETF.31 PSETF.32 PSETF.33 PSETF.34 PSETF.35

 PSETF.36 PSETF.37 PSETF.38 PSETF.39 PSETF.40 SHIFTF-ORDER.1

 SHIFTF-ORDER.2 SHIFTF.1 SHIFTF.2 SHIFTF.3 SHIFTF.4 SHIFTF.5 SHIFTF.6

 ROTATEF-ORDER.1 ROTATEF-ORDER.2 ROTATEF.1 ROTATEF.2 ROTATEF.3 ROTATEF.4

 ROTATEF.5 ROTATEF.6 ROTATEF.7 ROTATEF.8 ROTATEF.9 ROTATEF.10 ROTATEF.11

 ROTATEF.12 ROTATEF.13 ROTATEF.14 ROTATEF.15 ROTATEF.16 ROTATEF.17

 ROTATEF.18 ROTATEF.21 ROTATEF.22 ROTATEF.23 ROTATEF.24 ROTATEF.25

 ROTATEF.26 ROTATEF.27 ROTATEF.28 ROTATEF.29 ROTATEF.30 ROTATEF.31

 ROTATEF.32 ROTATEF.33 ROTATEF.34 ROTATEF.35 ROTATEF.36 ROTATEF.37

 RETURN.ERROR.1 RETURN.ERROR.2 RETURN.ERROR.3 RETURN.1 RETURN.2 RETURN.3

 RETURN-FROM.1 RETURN-FROM.2 RETURN-FROM.3 DEFSETF.ERROR.1 DEFSETF.1

 DEFSETF.2A DEFSETF.2B DEFSETF.3A DEFSETF.3B DEFSETF.3C DEFSETF.4A

 DEFSETF.4B DEFSETF.4C DEFSETF.5A DEFSETF.6A

 DEFINE-SETF-EXPANDER.ERROR.1 DEFINE-SETF-EXPANDER.1

 DEFINE-SETF-EXPANDER.2 DEFINE-SETF-EXPANDER.3 DEFINE-SETF-EXPANDER.4

 DEFINE-SETF-EXPANDER.5 DEFINE-SETF-EXPANDER.6 DEFINE-SETF-EXPANDER.7

 AND.1 AND.2 AND.3 AND.4 AND.5 AND.6 AND.7 AND.8 AND.9 AND.10

 AND.ORDER.1 AND.ORDER.2 AND.ERROR.1 AND.ERROR.2 AND.ERROR.3

 APPLY.ERROR.1 APPLY.ERROR.2 APPLY.ERROR.3 APPLY.ERROR.4 APPLY.1 APPLY.2

 APPLY.3 APPLY.4 APPLY.5 APPLY.6 APPLY.7 APPLY.8 APPLY.ORDER.1 BLOCK.1

 BLOCK.2 BLOCK.3 BLOCK.4 BLOCK.5 BLOCK.6 BLOCK.7 BLOCK.8 BLOCK.9

 BLOCK.10 BLOCK.11 BLOCK.12 CALL-ARGUMENTS-LIMIT.1

 CALL-ARGUMENTS-LIMIT.2 CALL-ARGUMENTS-LIMIT.3 CALL-ARGUMENTS-LIMIT.4

 CALL-ARGUMENTS-LIMIT.5 CASE.1 CASE.2 CASE.3 CASE.4 CASE.5 CASE.6 CASE.7

 CASE.8 CASE.9 CASE.10 CASE.11 CASE.12 CASE.13 CASE.14 CASE.15 CASE.16

 CASE.17 CASE.18 CASE.19 CASE.20 CASE.21 CASE.22 CASE.23 CASE.24 CASE.25

 CASE.26 CASE.27 CASE.28 CASE.29 CASE.30 CASE.31 CASE.32 CASE.33 CASE.34

 CASE.35 CASE.36 CASE.37 CASE.ERROR.1 CASE.ERROR.2 CASE.ERROR.3 CATCH.1

 CATCH.2 CATCH.3 CATCH.4 CATCH.5 CATCH.6 CATCH.7 CATCH.8 CATCH.9

 CATCH.10 CATCH.11 CATCH.12 CATCH.13 CATCH.14 CATCH.15 CATCH.16

 THROW-ERROR CCASE.1 CCASE.2 CCASE.3 CCASE.4 CCASE.5 CCASE.6 CCASE.7

 CCASE.8 CCASE.9 CCASE.10 CCASE.11 CCASE.12 CCASE.13 CCASE.14 CCASE.15

 CCASE.16 CCASE.17 CCASE.19 CCASE.20 CCASE.21 CCASE.23 CCASE.25 CCASE.26

 CCASE.27 CCASE.28 CCASE.29 CCASE.30 CCASE.31 CCASE.32 CCASE.33

 CCASE.ERROR.1 CCASE.ERROR.2 CCASE.ERROR.3 COMPILED-FUNCTION-P.1

 COMPILED-FUNCTION-P.2E31.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E31.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E31.exp
 COMPILED-FUNCTION-P.3 COMPILED-FUNCTION-P.ORDER.1

 COMPILED-FUNCTION-P.ERROR.1 COMPILED-FUNCTION-P.ERROR.2 COMPLEMENT.1

 COMPLEMENT.2 COMPLEMENT.3 COMPLEMENT.4 COMPLEMENT.5 COMPLEMENT.6

 COMPLEMENT.7 COMPLEMENT.8 COMPLEMENT.9E34.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E34.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E34.exp
 COMPLEMENT.10 COMPLEMENT.ORDER.1

 COMPLEMENT.ERROR.1 COMPLEMENT.ERROR.2 COMPLEMENT.ERROR.3

 COMPLEMENT.ERROR.4 COMPLEMENT.ERROR.5 COMPLEMENT.ERROR.6

 COMPLEMENT.ERROR.7 COND.1 COND.2 COND.3 COND.4 COND.5 COND.6 COND.7

 COND.8 COND.9 COND.10 COND.11 COND.12 COND.13 COND.14 COND.15 COND.16

 COND.17 COND.ERROR.1 COND.ERROR.2 COND.ERROR.3 CONSTANTLY.1

 CONSTANTLY.2 CONSTANTLY.3 CONSTANTLY.ERROR.1 CONSTANTLY.ERROR.2

 CTYPECASE.1 CTYPECASE.2 CTYPECASE.3 CTYPECASE.4 CTYPECASE.5 CTYPECASE.6

 CTYPECASE.7 CTYPECASE.8 CTYPECASE.9 CTYPECASE.10 CTYPECASE.11

 CTYPECASE.12 CTYPECASE.13 CTYPECASE.14

Test CTYPECASE.15 failed

Form: (MACROLET ((%M (Z)

                   Z))

        (CTYPECASE (EXPAND-IN-CURRENT-ENV (%M :FOO))

          (INTEGER :BAD1)

          (KEYWORD :GOOD)

          (SYMBOL :BAD2)))

Expected value: :GOOD

Actual value: #<a SIMPLE-PROGRAM-ERROR>.

Test CTYPECASE.16 failed

Form: (MACROLET ((%M (Z)

                   Z))

        (CTYPECASE :FOO

          (INTEGER (EXPAND-IN-CURRENT-ENV (%M :BAD1)))

          (KEYWORD (EXPAND-IN-CURRENT-ENV (%M :GOOD)))

          (SYMBOL (EXPAND-IN-CURRENT-ENV (%M :BAD2)))))

Expected value: :GOOD

Actual value: #<a SIMPLE-PROGRAM-ERROR>.

 CTYPECASE.ERROR.1 CTYPECASE.ERROR.2 CTYPECASE.ERROR.3 DEFCONSTANT.1

 DEFCONSTANT.2 DEFCONSTANT.3 DEFCONSTANT.4 DEFCONSTANT.5

 DEFCONSTANT.ERROR.1 DEFCONSTANT.ERROR.2 DEFCONSTANT.ERROR.3

 DEFINE-MODIFY-MACRO.1 DEFINE-MODIFY-MACRO.2 DEFINE-MODIFY-MACRO.3

 DEFINE-MODIFY-MACRO.4 DEFINE-MODIFY-MACRO.ERROR.1

 DEFINE-MODIFY-MACRO.DOCUMENTATION.1 DEFINE-MODIFY-MACRO.DOCUMENTATION.2

 DEFPARAMETER.1 DEFPARAMETER.2 DEFPARAMETER.3 DEFPARAMETER.4

 DEFPARAMETER.5 DEFPARAMETER.ERROR.1 DEFPARAMETER.ERROR.2

 DEFPARAMETER.ERROR.3 DEFUN.1 DEFUN.2 DEFUN.3 DEFUN.4 DEFUN.5 DEFUN.6

 DEFUN.7 DEFUN.8 DEFUN.ERROR.1 DEFUN.ERROR.2 DEFUN.ERROR.3 DEFUN.ERROR.4

 DEFVAR.1 DEFVAR.2 DEFVAR.3 DEFVAR.4 DEFVAR.5 DEFVAR.ERROR.1

 DEFVAR.ERROR.2 DEFVAR.ERROR.3 DESTRUCTURING-BIND.1 DESTRUCTURING-BIND.2

 DESTRUCTURING-BIND.3 DESTRUCTURING-BIND.4 DESTRUCTURING-BIND.5

 DESTRUCTURING-BIND.6 DESTRUCTURING-BIND.7 DESTRUCTURING-BIND.7A

 DESTRUCTURING-BIND.8 DESTRUCTURING-BIND.9 DESTRUCTURING-BIND.10

 DESTRUCTURING-BIND.11 DESTRUCTURING-BIND.12 DESTRUCTURING-BIND.12A

 DESTRUCTURING-BIND.13 DESTRUCTURING-BIND.14 DESTRUCTURING-BIND.15

 DESTRUCTURING-BIND.16 DESTRUCTURING-BIND.17 DESTRUCTURING-BIND.17A

 DESTRUCTURING-BIND.17C DESTRUCTURING-BIND.18 DESTRUCTURING-BIND.19

 DESTRUCTURING-BIND.20 DESTRUCTURING-BIND.21 DESTRUCTURING-BIND.22

 DESTRUCTURING-BIND.23 DESTRUCTURING-BIND.24 DESTRUCTURING-BIND.25

 DESTRUCTURING-BIND.26 DESTRUCTURING-BIND.27 DESTRUCTURING-BIND.28

 DESTRUCTURING-BIND.29 DESTRUCTURING-BIND.30 DESTRUCTURING-BIND.31

 DESTRUCTURING-BIND.ERROR.7 DESTRUCTURING-BIND.ERROR.8

 DESTRUCTURING-BIND.ERROR.9 ECASE.1 ECASE.2 ECASE.3 ECASE.4 ECASE.5

 ECASE.6 ECASE.7 ECASE.8 ECASE.9 ECASE.10 ECASE.11 ECASE.12 ECASE.13

 ECASE.14 ECASE.15 ECASE.16 ECASE.17 ECASE.18 ECASE.19 ECASE.20 ECASE.21

 ECASE.23 ECASE.25 ECASE.26 ECASE.27 ECASE.28 ECASE.29 ECASE.31 ECASE.32

 ECASE.33 ECASE.34 ECASE.ERROR.1 ECASE.ERROR.2 ECASE.ERROR.3 EQL.1 EQL.2

 EQL.3 EQL.4 EQL.5 EQL.7 EQL.8 EQL.9 EQL.10 EQL.11 EQL.ORDER.1

 EQL.ERROR.1 EQL.ERROR.2 EQL.ERROR.3 EQ.ERROR.1 EQ.ERROR.2 EQ.ERROR.3

 EQUAL.1 EQUAL.2 EQUAL.3 EQUAL.4 EQUAL.5 EQUAL.6 EQUAL.7 EQUAL.8 EQUAL.9

 EQUAL.10 EQUAL.11 EQUAL.12 EQUAL.15 EQUAL.16 EQUAL.17 EQUAL.18 EQUAL.19

 EQUAL.ORDER.1 EQUAL.ERROR.1 EQUAL.ERROR.2 EQUAL.ERROR.3 EQUALP.1

 EQUALP.2 EQUALP.3 EQUALP.4

Test EQUALP.5 failed

Form: (EQUALPT (MAKE-ARRAY '(0) :ELEMENT-TYPE NIL) #())

Expected value: T

Actual value: #<a SIMPLE-ERROR>.

Test EQUALP.6 failed

Form: (EQUALPT (MAKE-ARRAY '(0) :ELEMENT-TYPE NIL) "")

Expected value: T

Actual value: #<a SIMPLE-ERROR>.

 EQUALP.7 EQUALP.8 EQUALP.9 EQUALP.10 EQUALP.11 EQUALP.12 EQUALP.13

 EQUALP.14 EQUALP.15 EQUALP.16 EQUALP.17 EQUALP.18 EQUALP.19 EQUALP.20

 EQUALP.21 EQUALP.22 EQUALP.23 EQUALP.24 EQUALP.25 EQUALP.26 EQUALP.27

 EQUALP.28 EQUALP.29 EQUALP.30 EQUALP.31 EQUALP.32 EQUALP.33 EQUALP.34

 EQUALP.35 EQUALP.ORDER.1 EQUALP.ERROR.1 EQUALP.ERROR.2 EQUALP.ERROR.3

 ETYPECASE.1 ETYPECASE.2 ETYPECASE.3 ETYPECASE.4 ETYPECASE.5 ETYPECASE.6

 ETYPECASE.7 ETYPECASE.8 ETYPECASE.9 ETYPECASE.10 ETYPECASE.11

 ETYPECASE.12 ETYPECASE.13 ETYPECASE.14 ETYPECASE.15 ETYPECASE.16

 ETYPECASE.17 ETYPECASE.ERROR.1 ETYPECASE.ERROR.2 ETYPECASE.ERROR.3

 EVERY.1 EVERY.2 EVERY.3 EVERY.4 EVERY.5 EVERY.6 EVERY.7 EVERY.8 EVERY.9

 EVERY.10 EVERY.11 EVERY.12 EVERY.13 EVERY.14 EVERY.15 EVERY.16 EVERY.17

 EVERY.18 EVERY.19 EVERY.20 EVERY.21 EVERY.22 EVERY.23 EVERY.24 EVERY.25

 EVERY.26 EVERY.27 EVERY.28 EVERY.29 EVERY.30 EVERY.31 EVERY.32

 EVERY.ORDER.1 EVERY.ORDER.2 EVERY.ERROR.1 EVERY.ERROR.2 EVERY.ERROR.3

 EVERY.ERROR.8 EVERY.ERROR.9 EVERY.ERROR.10 EVERY.ERROR.11

 EVERY.ERROR.12 EVERY.ERROR.13

Test EVERY.ERROR.14 failed

Form: (SIGNALS-ERROR (EVERY #'IDENTITY '(1 2 3 . 4)) TYPE-ERROR)

Expected value: T

Actual values: NIL

               ((TYPEP '(1 2 3 . 4) 'SEQUENCE) "==> true").

 FBOUNDP.1 FBOUNDP.2 FBOUNDP.3 FBOUNDP.4 FBOUNDP.5 FBOUNDP.6 FBOUNDP.7

 FBOUNDP.8 FBOUNDP.ORDER.1 FBOUNDP.ERROR.1 FBOUNDP.ERROR.2

 FBOUNDP.ERROR.3 FBOUNDP.ERROR.4 FBOUNDP.ERROR.5 FBOUNDP.ERROR.6

 FBOUNDP.ERROR.7 FBOUNDP.ERROR.8 FBOUNDP.ERROR.9 FBOUNDP.ERROR.10

 FDEFINITION.ERROR.1 FDEFINITION.ERROR.2 FDEFINITION.ERROR.3

 FDEFINITION.ERROR.4 FDEFINITION.ERROR.6 FDEFINITION.ERROR.7

 FDEFINITION.ERROR.8 FDEFINITION.1 FDEFINITION.2 FDEFINITION.3

 FDEFINITION.4 FDEFINITION.5 FDEFINITION.ORDER.1 FLET.1 FLET.2 FLET.3

 FLET.4 FLET.4A FLET.5 FLET.6 FLET.7 FLET.8 FLET.9 FLET.10 FLET.11

 FLET.12 FLET.13 FLET.14 FLET.15 FLET.16 FLET.17 FLET.18 FLET.19 FLET.20

 FLET.21 FLET.22 FLET.23 FLET.24 FLET.25 FLET.26 FLET.27 FLET.28 FLET.29

 FLET.30 FLET.31 FLET.32 FLET.33 FLET.34 FLET.35 FLET.36 FLET.37 FLET.38

 FLET.39 FLET.40 FLET.45 FLET.46 FLET.47 FLET.48 FLET.49 FLET.50 FLET.51

 FLET.52 FLET.53 FLET.54 FLET.55 FLET.56 FLET.57 FLET.58 FLET.59 FLET.60

 FLET.61 FLET.62 FLET.63 FLET.64 FLET.65 FLET.66 FLET.67 FLET.68 FLET.69

 FLET.70 FLET.71 FMAKUNBOUND.1 FMAKUNBOUND.2 FMAKUNBOUND.3 FMAKUNBOUND.4

 FMAKUNBOUND.ERROR.1 FMAKUNBOUND.ERROR.2 FMAKUNBOUND.ERROR.3

 FMAKUNBOUND.ERROR.4 FMAKUNBOUND.ERROR.5 FMAKUNBOUND.ERROR.6

 FMAKUNBOUND.ERROR.7 FUNCALL.1 FUNCALL.2 FUNCALL.3 FUNCALL.4 FUNCALL.5

 FUNCALL.6 FUNCALL.7 FUNCALL.8 FUNCALL.9 FUNCALL.ORDER.1 FUNCALL.ORDER.2

 FUNCALL.ERROR.1 FUNCALL.ERROR.2 FUNCALL.ERROR.3 FUNCALL.ERROR.4

 FUNCALL.ERROR.5 FUNCALL.ERROR.6 FUNCALL.ERROR.7

 FUNCTION-LAMBDA-EXPRESSION.1 FUNCTION-LAMBDA-EXPRESSION.2

 FUNCTION-LAMBDA-EXPRESSION.3 FUNCTION-LAMBDA-EXPRESSION.ORDER.1

 FUNCTION-LAMBDA-EXPRESSION.ERROR.1 FUNCTION-LAMBDA-EXPRESSION.ERROR.2

 FUNCTION.1 FUNCTION.2 FUNCTION.3 FUNCTION.4 FUNCTION.5 FUNCTION.6

 FUNCTION.7 FUNCTION.8E37.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E37.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E37.exp
 FUNCTION.9 FUNCTION.10 FUNCTION.11 FUNCTION.12

 FUNCTION.13 FUNCTION.14 FUNCTION.15 FUNCTION.16 FUNCTION.17 FUNCTION.18

 FUNCTION.19 FUNCTION.20 FUNCTION.21 FUNCTION.22 FUNCTION.23 FUNCTION.24

 FUNCTIONP.1 FUNCTIONP.2 FUNCTIONP.3 FUNCTIONP.4 FUNCTIONP.5 FUNCTIONP.6

 FUNCTIONP.7 FUNCTIONP.8E3A.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E3A.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E3A.exp
 FUNCTIONP.9 FUNCTIONP.10 FUNCTIONP.11

 FUNCTIONP.12 FUNCTIONP.ORDER.1 FUNCTIONP.ERROR.1 FUNCTIONP.ERROR.2

 GET-SETF-EXPANSION.ERROR.1 GET-SETF-EXPANSION.ERROR.2

 GET-SETF-EXPANSION.1 GET-SETF-EXPANSION.2 GET-SETF-EXPANSION.3

 IDENTITY.1 IDENTITY.2 IDENTITY.3 IDENTITY.ORDER.1 IDENTITY.ERROR.1

 IDENTITY.ERROR.2 IF.1 IF.2 IF.3 IF.4 IF.5 IF.6 IF.7 IF.8 IF.9 IF.10

 IF.11 IF.12 IF.13 IF.ORDER.1 LABELS.1 LABELS.2 LABELS.3 LABELS.4

 LABELS.4A LABELS.5 LABELS.6 LABELS.7 LABELS.7B LABELS.7C LABELS.7D

 LABELS.8 LABELS.9 LABELS.10 LABELS.11 LABELS.12 LABELS.13 LABELS.14

 LABELS.15 LABELS.16 LABELS.17 LABELS.18 LABELS.19 LABELS.20 LABELS.21

 LABELS.22 LABELS.23 LABELS.24 LABELS.25 LABELS.26 LABELS.27 LABELS.28

 LABELS.29 LABELS.30 LABELS.31 LABELS.32 LABELS.33 LABELS.34 LABELS.35

 LABELS.36 LABELS.37 LABELS.38 LABELS.39 LABELS.40 LABELS.41 LABELS.42

 LABELS.43 LABELS.44 LABELS.45 LABELS.46 LABELS.47 LABELS.48 LABELS.49

 LAMBDA-LIST-KEYWORDS.1 LAMBDA-LIST-KEYWORDS.2 LAMBDA-LIST-KEYWORDS.3

 LAMBDA-LIST-KEYWORDS.5 LAMBDA-PARAMETERS-LIMIT.1

 LAMBDA-PARAMETERS-LIMIT.2 LET.1 LET.2 LET.3 LET.4 LET.5 LET.6 LET.7

 LET.9 LET.11 LET.14 LET.15 LET.16 LET.17E3D.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E3D.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E3D.exp
 LET.17A LET.18 LET.19 LET.20

 LET.21 LET*.1 LET*.2 LET*.3 LET*.4 LET*.5 LET*.6 LET*.7 LET*.8 LET*.9

 LET*.10 LET*.11 LET*.12 LET*.14 LET*.15 LET*.16 LET*.17E40.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E40.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E40.exp
 LET*.17A

 LET*.18 LET*.19 LET*.20 LET*.21 LET*.22 LET*.23 MACROLET.1 MACROLET.2

 MACROLET.3 MACROLET.4 MACROLET.5 MACROLET.6 MACROLET.7 MACROLET.8

 MACROLET.9 MACROLET.10 MACROLET.11 MACROLET.12 MACROLET.13 MACROLET.14

 MACROLET.15 MACROLET.16 MACROLET.17 MACROLET.18 MACROLET.19 MACROLET.20

 MACROLET.21 MACROLET.22 MACROLET.22A MACROLET.23 MACROLET.24

 MACROLET.25 MACROLET.26 MACROLET.27 MACROLET.28 MACROLET.29 MACROLET.30

 MACROLET.31 MACROLET.32 MACROLET.33 MACROLET.34 MACROLET.35 MACROLET.36

 MACROLET.37 MACROLET.38 MACROLET.39 MACROLET.40 MACROLET.41 MACROLET.42

 MACROLET.43 MACROLET.44 MACROLET.45 MACROLET.46 MACROLET.47 MACROLET.48

 MACROLET.49 MULTIPLE-VALUE-BIND.1 MULTIPLE-VALUE-BIND.2

 MULTIPLE-VALUE-BIND.3 MULTIPLE-VALUE-BIND.4 MULTIPLE-VALUE-BIND.5

 MULTIPLE-VALUE-BIND.6 MULTIPLE-VALUE-BIND.7 MULTIPLE-VALUE-BIND.8

 MULTIPLE-VALUE-BIND.9 MULTIPLE-VALUE-BIND.10 MULTIPLE-VALUE-BIND.11

 MULTIPLE-VALUE-BIND.12 MULTIPLE-VALUE-BIND.13 MULTIPLE-VALUE-BIND.14

 MULTIPLE-VALUE-BIND.ERROR.1 MULTIPLE-VALUE-BIND.ERROR.2

 MULTIPLE-VALUE-BIND.ERROR.3 MULTIPLE-VALUE-CALL.1 MULTIPLE-VALUE-CALL.2

 MULTIPLE-VALUE-CALL.3 MULTIPLE-VALUE-CALL.4 MULTIPLE-VALUE-CALL.5

 MULTIPLE-VALUE-PROG1.1 MULTIPLE-VALUE-PROG1.2 MULTIPLE-VALUE-PROG1.3

 MULTIPLE-VALUE-PROG1.4 MULTIPLE-VALUE-PROG1.5 MULTIPLE-VALUE-PROG1.6

 MULTIPLE-VALUE-PROG1.7 MULTIPLE-VALUE-PROG1.8 MULTIPLE-VALUE-PROG1.9

 MULTIPLE-VALUE-PROG1.10 MULTIPLE-VALUE-PROG1.11 MULTIPLE-VALUE-PROG1.12

 MULTIPLE-VALUE-SETQ.1 MULTIPLE-VALUE-SETQ.2 MULTIPLE-VALUE-SETQ.3

 MULTIPLE-VALUE-SETQ.4 MULTIPLE-VALUE-SETQ.5 MULTIPLE-VALUE-SETQ.6

 MULTIPLE-VALUE-SETQ.7 MULTIPLE-VALUE-SETQ.8 MULTIPLE-VALUE-SETQ.9

 MULTIPLE-VALUE-SETQ.10 MULTIPLE-VALUE-SETQ.11 MULTIPLE-VALUE-SETQ.12

 MULTIPLE-VALUE-SETQ.13 MULTIPLE-VALUE-SETQ.14 MULTIPLE-VALUE-SETQ.15

 MULTIPLE-VALUE-SETQ.16 MULTIPLE-VALUE-SETQ.17

 MULTIPLE-VALUE-SETQ.ERROR.1 MULTIPLE-VALUE-SETQ.ERROR.2

 MULTIPLE-VALUE-SETQ.ERROR.3 MULTIPLE-VALUE-LIST.1 MULTIPLE-VALUE-LIST.2

 MULTIPLE-VALUE-LIST.3 MULTIPLE-VALUE-LIST.4 MULTIPLE-VALUE-LIST.5

 MULTIPLE-VALUE-LIST.6 MULTIPLE-VALUE-LIST.7 MULTIPLE-VALUE-LIST.8

 MULTIPLE-VALUE-LIST.9 MULTIPLE-VALUE-LIST.ORDER.1

 MULTIPLE-VALUE-LIST.ERROR.1 MULTIPLE-VALUE-LIST.ERROR.2

 MULTIPLE-VALUE-LIST.ERROR.3 NIL.1 NIL.2 NIL.3 NIL.4 NIL.5 NIL.6 NIL.7

 NIL.8 NULL.1 NULL.2 NULL.3 NULL.4 NULL.ERROR.1 NULL.ERROR.2 NOT.1 NOT.2

 NOT.3 NOT.4 NOT.ERROR.1 NOT.ERROR.2 NOTANY.1 NOTANY.2 NOTANY.3 NOTANY.4

 NOTANY.5 NOTANY.6 NOTANY.7 NOTANY.8 NOTANY.9 NOTANY.10 NOTANY.11

 NOTANY.12 NOTANY.13 NOTANY.14 NOTANY.15 NOTANY.16 NOTANY.17 NOTANY.18

 NOTANY.19 NOTANY.20 NOTANY.21 NOTANY.22 NOTANY.23 NOTANY.24 NOTANY.25

 NOTANY.26 NOTANY.27 NOTANY.28 NOTANY.29 NOTANY.30 NOTANY.31 NOTANY.32

 NOTANY.ORDER.1 NOTANY.ERROR.1 NOTANY.ERROR.4 NOTANY.ERROR.7

 NOTANY.ERROR.8 NOTANY.ERROR.9 NOTANY.ERROR.10 NOTANY.ERROR.11

 NOTANY.ERROR.12 NOTANY.ERROR.13 NOTEVERY.1 NOTEVERY.2 NOTEVERY.3

 NOTEVERY.4 NOTEVERY.5 NOTEVERY.6 NOTEVERY.7 NOTEVERY.8 NOTEVERY.9

 NOTEVERY.10 NOTEVERY.11 NOTEVERY.12 NOTEVERY.13 NOTEVERY.14 NOTEVERY.15

 NOTEVERY.16 NOTEVERY.17 NOTEVERY.18 NOTEVERY.19 NOTEVERY.20 NOTEVERY.21

 NOTEVERY.22 NOTEVERY.23 NOTEVERY.24 NOTEVERY.25 NOTEVERY.26 NOTEVERY.27

 NOTEVERY.28 NOTEVERY.29 NOTEVERY.30 NOTEVERY.31 NOTEVERY.32

 NOTEVERY.ORDER.1 NOTEVERY.ERROR.1 NOTEVERY.ERROR.4 NOTEVERY.ERROR.7

 NOTEVERY.ERROR.8 NOTEVERY.ERROR.9 NOTEVERY.ERROR.10 NOTEVERY.ERROR.11

 NOTEVERY.ERROR.12 NOTEVERY.ERROR.13 NTH-VALUE.1 NTH-VALUE.2 NTH-VALUE.3

 NTH-VALUE.4 NTH-VALUE.5 NTH-VALUE.6 NTH-VALUE.7 NTH-VALUE.ORDER.1

 NTH-VALUE.ERROR.1 NTH-VALUE.ERROR.2 NTH-VALUE.ERROR.3 OR.1 OR.2 OR.3

 OR.4 OR.5 OR.6 OR.7 OR.8 OR.9 OR.10 OR.11 OR.ERROR.1 OR.ERROR.2

 OR.ERROR.3 PROG.1 PROG.2 PROG.3 PROG.4 PROG.5 PROG.6 PROG.7 PROG.8

 PROG.9 PROG.10 PROG.11 PROG.12 PROG.ERROR.1 PROG*.1 PROG*.2 PROG*.3

 PROG*.4 PROG*.5 PROG*.6 PROG*.7 PROG*.8 PROG*.9 PROG*.10 PROG*.11

 PROG*.12 PROG*.ERROR.1 PROG1.1 PROG1.2 PROG1.3 PROG1.4 PROG1.5 PROG1.6

 PROG1.7 PROG1.ERROR.1 PROG2.1 PROG2.2 PROG2.3 PROG2.4 PROG2.5 PROG2.6

 PROG2.7 PROG2.8 PROG2.ERROR.1 PROGN.1 PROGN.2 PROGN.3 PROGN.4 PROGN.5

 PROGN.6 PROGN.7 PROGN.8 PROGN.9 PROGN.10 PROGV.1 PROGV.2 PROGV.3

 PROGV.4 PROGV.5 PROGV.6 PROGV.6A PROGV.7 PROGV.8 PROGV.9 PROGV.10

 PROGV.11 PROGV.12 PROGV.13 PROGV.14 PROGV.15 PROGV.16 PROGV.17 SOME.1

 SOME.2 SOME.3 SOME.4 SOME.5 SOME.6 SOME.7 SOME.8 SOME.9 SOME.10 SOME.11

 SOME.12 SOME.13 SOME.14 SOME.15 SOME.16 SOME.17 SOME.18 SOME.19 SOME.20

 SOME.21 SOME.22 SOME.23 SOME.24 SOME.25 SOME.26 SOME.27 SOME.28 SOME.29

 SOME.30 SOME.31 SOME.32 SOME.ORDER.1 SOME.ORDER.2 SOME.ERROR.1

 SOME.ERROR.4 SOME.ERROR.7 SOME.ERROR.8 SOME.ERROR.9 SOME.ERROR.10

 SOME.ERROR.11 SOME.ERROR.12 SOME.ERROR.13 SOME.ERROR.14 T.1 T.2 T.3 T.4

 TAGBODY.1 TAGBODY.2 TAGBODY.3 TAGBODY.4 TAGBODY.5 TAGBODY.6 TAGBODY.7

 TAGBODY.8 TAGBODY.9 TAGBODY.10 TAGBODY.11 TAGBODY.12 TAGBODY.13

 TAGBODY.14 TAGBODY.15 TAGBODY.16 TAGBODY.17 TAGBODY.18 TYPECASE.1

 TYPECASE.2 TYPECASE.3 TYPECASE.4 TYPECASE.5 TYPECASE.6 TYPECASE.7

 TYPECASE.8 TYPECASE.9 TYPECASE.10 TYPECASE.11 TYPECASE.12 TYPECASE.13

 TYPECASE.14 TYPECASE.15 TYPECASE.16 TYPECASE.17 TYPECASE.18 TYPECASE.19

 TYPECASE.20 TYPECASE.21 TYPECASE.ERROR.1 TYPECASE.ERROR.2

 TYPECASE.ERROR.3 UNLESS.1 UNLESS.2 UNLESS.3 UNLESS.4 UNLESS.5 UNLESS.6

 UNLESS.7 UNLESS.8 UNLESS.9 UNLESS.10 UNLESS.11 UNLESS.12 UNLESS.13

 UNLESS.ERROR.1 UNLESS.ERROR.2 UNLESS.ERROR.3 UNWIND-PROTECT.1

 UNWIND-PROTECT.2 UNWIND-PROTECT.3 UNWIND-PROTECT.4 UNWIND-PROTECT.5

 UNWIND-PROTECT.6 UNWIND-PROTECT.7 UNWIND-PROTECT.8 UNWIND-PROTECT.9

 UNWIND-PROTECT.10 UNWIND-PROTECT.11 UNWIND-PROTECT.12 UNWIND-PROTECT.13

 VALUES-LIST.ERROR.1 VALUES-LIST.ERROR.2 VALUES-LIST.ERROR.3

 VALUES-LIST.ERROR.4 VALUES-LIST.1 VALUES-LIST.2 VALUES-LIST.3

 VALUES-LIST.4 VALUES-LIST.5 VALUES.0 VALUES.1 VALUES.2 VALUES.3

 VALUES.4 VALUES.10 VALUES.15 VALUES.19 VALUES.20 VALUES.21 VALUES.A

 VALUES.B VALUES.C VALUES.ORDER.1 WHEN.1 WHEN.2 WHEN.3 WHEN.4 WHEN.5

 WHEN.6 WHEN.7 WHEN.8 WHEN.9 WHEN.10 WHEN.11 WHEN.ERROR.1 WHEN.ERROR.2

 WHEN.ERROR.3 DO.1 DO.2 DO.3 DO.4 DO.5 DO.6 DO.7 DO.8 DO.9 DO.10 DO.11

 DO.12 DO.13 DO.14 DO.15 DO.16 DO.17 DO.18 DO.19 DO.20 DO.21 DO.22 DO.23

 DO.ERROR.1 DO*.1 DO*.2 DO*.3 DO*.4 DO*.5 DO*.6 DO*.7 DO*.8 DO*.9 DO*.10

 DO*.11 DO*.12 DO*.13 DO*.14 DO*.15 DO*.16 DO*.17 DO*.18 DO*.19 DO*.20

 DO*.21 DO*.22 DO*.23 DO*.ERROR.1 DOLIST.1 DOLIST.2 DOLIST.3 DOLIST.4

 DOLIST.5 DOLIST.6 DOLIST.7 DOLIST.8 DOLIST.9 DOLIST.10 DOLIST.11

 DOLIST.12 DOLIST.13 DOLIST.14 DOLIST.15 DOLIST.16 DOLIST.17 DOLIST.18

 DOLIST.19 DOLIST.ERROR.1 DOTIMES.1 DOTIMES.2 DOTIMES.3 DOTIMES.3A

 DOTIMES.4 DOTIMES.5 DOTIMES.6 DOTIMES.7 DOTIMES.8 DOTIMES.9 DOTIMES.10

 DOTIMES.11 DOTIMES.12 DOTIMES.13 DOTIMES.14 DOTIMES.15 DOTIMES.16

 DOTIMES.17 DOTIMES.17A DOTIMES.18 DOTIMES.18A DOTIMES.19 DOTIMES.20

 DOTIMES.21 DOTIMES.22 DOTIMES.23 DOTIMES.23A DOTIMES.24 DOTIMES.25

 DOTIMES.26 DOTIMES.ERROR.1 SLOOP.1 SLOOP.2 SLOOP.3 SLOOP.4 SLOOP.5

 SLOOP.6 SLOOP.7 LOOP.ERROR.1 LOOP-FINISH.ERROR.1 LOOP.1.1 LOOP.1.2

 LOOP.1.3 LOOP.1.4 LOOP.1.5 LOOP.1.6 LOOP.1.7 LOOP.1.8 LOOP.1.9

 LOOP.1.10 LOOP.1.11 LOOP.1.12 LOOP.1.13 LOOP.1.14 LOOP.1.15 LOOP.1.16

 LOOP.1.17 LOOP.1.18 LOOP.1.19 LOOP.1.20 LOOP.1.21 LOOP.1.22 LOOP.1.23

 LOOP.1.24 LOOP.1.25 LOOP.1.26 LOOP.1.27 LOOP.1.28 LOOP.1.29 LOOP.1.30

 LOOP.1.31 LOOP.1.32 LOOP.1.33 LOOP.1.34 LOOP.1.35 LOOP.1.36 LOOP.1.37

 LOOP.1.38;;; Warning: The form #C(0 1) evaluated to #C(0 1), which was not of the anticipated type REAL.

Current LOOP context: FOR C FROM #C(0 1) COLLECT.

 LOOP.1.44;;; Warning: The form #C(0 1) evaluated to #C(0 1), which was not of the anticipated type REAL.

Current LOOP context: FOR C FROM #C(0 1) BY 2 COLLECT.

 LOOP.1.45;;; Warning: The form #C(5 1) evaluated to #C(5 1), which was not of the anticipated type REAL.

Current LOOP context: FOR C DOWNFROM #C(5 1) COLLECT.

 LOOP.1.46;;; Warning: The form #C(10 1) evaluated to #C(10 1), which was not of the anticipated type REAL.

Current LOOP context: FOR C DOWNFROM #C(10 1) BY 2 COLLECT.

 LOOP.1.47;;; Warning: The form #C(0 1) evaluated to #C(0 1), which was not of the anticipated type REAL.

Current LOOP context: FOR C UPFROM #C(0 1) COLLECT.

 LOOP.1.48;;; Warning: The form #C(0 1) evaluated to #C(0 1), which was not of the anticipated type REAL.

Current LOOP context: FOR C UPFROM #C(0 1) BY 2 COLLECT.

 LOOP.1.49

 LOOP.1.50 LOOP.1.51 LOOP.1.52 LOOP.1.53 LOOP.1.54 LOOP.1.55 LOOP.1.56

 LOOP.1.57 LOOP.1.58 LOOP.1.59 LOOP.1.60 LOOP.1.61 LOOP.1.62 LOOP.1.63

 LOOP.1.64 LOOP.1.65 LOOP.2.1 LOOP.2.2 LOOP.2.3 LOOP.2.4 LOOP.2.5

 LOOP.2.6 LOOP.2.7 LOOP.2.8 LOOP.2.9 LOOP.2.10 LOOP.2.11 LOOP.2.12

 LOOP.2.13 LOOP.2.14 LOOP.2.15 LOOP.2.16 LOOP.2.17 LOOP.2.18 LOOP.2.19

 LOOP.2.20 LOOP.2.21 LOOP.2.22 LOOP.2.23 LOOP.2.24 LOOP.2.25 LOOP.2.26

 LOOP.3.1 LOOP.3.2 LOOP.3.3 LOOP.3.4 LOOP.3.5 LOOP.3.6 LOOP.3.7 LOOP.3.8

 LOOP.3.9 LOOP.3.10 LOOP.3.11 LOOP.3.12 LOOP.3.13 LOOP.3.14 LOOP.3.15

 LOOP.3.16 LOOP.3.17 LOOP.3.18 LOOP.3.19 LOOP.3.20 LOOP.3.21 LOOP.3.22

 LOOP.3.23 LOOP.3.24 LOOP.3.25 LOOP.3.26 LOOP.3.27 LOOP.4.1 LOOP.4.2

 LOOP.4.3 LOOP.4.4 LOOP.4.5 LOOP.4.6 LOOP.4.7 LOOP.4.8 LOOP.4.9

 LOOP.4.10 LOOP.4.11 LOOP.4.12 LOOP.4.13 LOOP.5.1 LOOP.5.2 LOOP.5.3

 LOOP.5.4 LOOP.5.5 LOOP.5.6 LOOP.5.7 LOOP.5.8 LOOP.5.10 LOOP.5.11

 LOOP.5.12 LOOP.5.13 LOOP.5.14 LOOP.5.20 LOOP.5.21 LOOP.5.22 LOOP.5.23

 LOOP.5.30 LOOP.5.32 LOOP.5.33 LOOP.5.34 LOOP.5.35 LOOP.5.36 LOOP.5.37

 LOOP.5.38 LOOP.5.39 LOOP.5.40 LOOP.5.41 LOOP.5.42 LOOP.5.43 LOOP.5.44

 LOOP.5.45 LOOP.5.ERROR.1 LOOP.5.ERROR.2 LOOP.5.ERROR.3 LOOP.5.ERROR.4

 LOOP.6.1 LOOP.6.2 LOOP.6.3 LOOP.6.4 LOOP.6.5 LOOP.6.6 LOOP.6.7 LOOP.6.8

 LOOP.6.9 LOOP.6.10 LOOP.6.11 LOOP.6.12 LOOP.6.13 LOOP.6.14 LOOP.6.15

 LOOP.6.16 LOOP.6.17 LOOP.6.18 LOOP.6.19 LOOP.6.20 LOOP.6.21 LOOP.6.22

 LOOP.6.23 LOOP.6.24 LOOP.6.25 LOOP.6.26 LOOP.6.27 LOOP.6.28 LOOP.6.29

 LOOP.6.30 LOOP.6.31 LOOP.6.32 LOOP.6.33 LOOP.6.34 LOOP.6.35 LOOP.6.36

 LOOP.6.37 LOOP.6.38 LOOP.6.39 LOOP.6.40 LOOP.6.41 LOOP.6.42

 LOOP.6.ERROR.1 LOOP.6.ERROR.2 LOOP.6.ERROR.3 LOOP.6.ERROR.4

 LOOP.6.ERROR.5 LOOP.7.1 LOOP.7.2 LOOP.7.3 LOOP.7.4 LOOP.7.5 LOOP.7.6

 LOOP.7.7 LOOP.7.8 LOOP.7.9 LOOP.7.10 LOOP.7.11 LOOP.7.12 LOOP.7.13

 LOOP.7.14 LOOP.7.15 LOOP.7.16 LOOP.7.17 LOOP.7.18 LOOP.7.19 LOOP.7.20

 LOOP.7.21 LOOP.7.22 LOOP.7.23 LOOP.7.24 LOOP.7.25 LOOP.7.26 LOOP.7.27

 LOOP.7.28 LOOP.7.29 LOOP.7.30 LOOP.7.31 LOOP.7.32 LOOP.7.33 LOOP.7.34

 LOOP.7.35 LOOP.8.1 LOOP.8.2 LOOP.8.3 LOOP.8.4 LOOP.8.5 LOOP.8.6

 LOOP.8.7 LOOP.8.8 LOOP.8.9 LOOP.8.10 LOOP.8.11 LOOP.8.12 LOOP.8.13

 LOOP.8.14 LOOP.8.15 LOOP.8.16 LOOP.8.17 LOOP.8.18 LOOP.8.19 LOOP.8.20

 LOOP.8.21 LOOP.8.22 LOOP.8.23 LOOP.8.24 LOOP.8.ERROR.1 LOOP.8.ERROR.2

 LOOP.9.1 LOOP.9.2 LOOP.9.3 LOOP.9.4 LOOP.9.5 LOOP.9.6 LOOP.9.7 LOOP.9.8

 LOOP.9.9 LOOP.9.10 LOOP.9.11 LOOP.9.12 LOOP.9.20 LOOP.9.21 LOOP.9.22

 LOOP.9.23 LOOP.9.24 LOOP.9.25 LOOP.9.26 LOOP.9.27 LOOP.9.28 LOOP.9.30

 LOOP.9.31 LOOP.9.32 LOOP.9.33 LOOP.9.34 LOOP.9.35 LOOP.9.36 LOOP.9.37

 LOOP.9.38 LOOP.9.40 LOOP.9.41 LOOP.9.42 LOOP.9.43 LOOP.9.44 LOOP.9.45

 LOOP.9.46 LOOP.9.47 LOOP.10.1 LOOP.10.2 LOOP.10.3 LOOP.10.4 LOOP.10.5

 LOOP.10.6 LOOP.10.7 LOOP.10.8 LOOP.10.9 LOOP.10.10 LOOP.10.11

 LOOP.10.12 LOOP.10.13 LOOP.10.14 LOOP.10.20 LOOP.10.21 LOOP.10.22

 LOOP.10.23 LOOP.10.24 LOOP.10.25 LOOP.10.26 LOOP.10.27 LOOP.10.28

 LOOP.10.29 LOOP.10.30 LOOP.10.31 LOOP.10.32 LOOP.10.33 LOOP.10.34

 LOOP.10.35 LOOP.10.36 LOOP.10.37 LOOP.10.38 LOOP.10.39 LOOP.10.40

 LOOP.10.41 LOOP.10.42 LOOP.10.43 LOOP.10.44 LOOP.10.45 LOOP.10.46

 LOOP.10.47 LOOP.10.48 LOOP.10.49 LOOP.10.50 LOOP.10.51 LOOP.10.52

 LOOP.10.53 LOOP.10.54 LOOP.10.55 LOOP.10.56 LOOP.10.57 LOOP.10.58

 LOOP.10.58A LOOP.10.59 LOOP.10.60 LOOP.10.61 LOOP.10.70 LOOP.10.71

 LOOP.10.72 LOOP.10.73 LOOP.10.74 LOOP.10.75 LOOP.10.76 LOOP.10.77

 LOOP.10.78 LOOP.10.79 LOOP.10.80 LOOP.10.81 LOOP.10.82 LOOP.10.83

 LOOP.10.84 LOOP.10.85 LOOP.10.86 LOOP.10.87 LOOP.10.88 LOOP.10.89

 LOOP.10.90 LOOP.10.91 LOOP.10.92 LOOP.10.93 LOOP.10.94 LOOP.10.95

 LOOP.10.96 LOOP.10.97 LOOP.10.98 LOOP.10.99 LOOP.10.100 LOOP.10.101

 LOOP.10.102 LOOP.10.103 LOOP.10.104 LOOP.10.105 LOOP.10.106 LOOP.10.107

 LOOP.10.108 LOOP.10.109 LOOP.10.110 LOOP.10.111 LOOP.10.112 LOOP.11.1

 LOOP.11.2 LOOP.11.3 LOOP.11.4 LOOP.11.5 LOOP.11.6 LOOP.11.7 LOOP.11.10

 LOOP.11.11 LOOP.11.12 LOOP.11.13 LOOP.11.14 LOOP.11.15 LOOP.11.16

 LOOP.11.17 LOOP.11.18 LOOP.11.20 LOOP.11.21 LOOP.11.22 LOOP.11.23

 LOOP.11.24 LOOP.11.25 LOOP.11.26 LOOP.11.27 LOOP.11.28 LOOP.11.29

 LOOP.11.30 LOOP.11.31 LOOP.11.32 LOOP.11.33 LOOP.11.34 LOOP.11.35

 LOOP.12.1 LOOP.12.2 LOOP.12.3 LOOP.12.4 LOOP.12.5 LOOP.12.6;;; Warning: LOOP clause is providing a value for the iteration,

however one was already established by a ALWAYS clause.

Current LOOP context: NEVER (> X 10).

 LOOP.12.7;;; Warning: LOOP clause is providing a value for the iteration,

however one was already established by a ALWAYS clause.

Current LOOP context: NEVER (> X 5).



 LOOP.12.8;;; Warning: LOOP clause is providing a value for the iteration,

however one was already established by a NEVER clause.

Current LOOP context: ALWAYS (< X 20).

 LOOP.12.9 LOOP.12.10 LOOP.12.11 LOOP.12.12 LOOP.12.13

 LOOP.12.21 LOOP.12.22 LOOP.12.23 LOOP.12.24 LOOP.12.25 LOOP.12.26

 LOOP.12.30 LOOP.12.31 LOOP.12.32 LOOP.12.33 LOOP.12.41 LOOP.12.42

 LOOP.12.43 LOOP.12.ERROR.50 LOOP.12.ERROR.50A LOOP.12.ERROR.51

 LOOP.12.ERROR.51A LOOP.12.ERROR.52 LOOP.12.ERROR.52A LOOP.12.53

 LOOP.12.53A LOOP.12.54 LOOP.12.54A LOOP.12.55 LOOP.12.55A LOOP.12.56

 LOOP.12.57 LOOP.12.58 LOOP.12.59 LOOP.12.60 LOOP.13.1 LOOP.13.2

 LOOP.13.3 LOOP.13.4 LOOP.13.5 LOOP.13.6 LOOP.13.7 LOOP.13.8 LOOP.13.9

 LOOP.13.10 LOOP.13.11 LOOP.13.12 LOOP.13.13 LOOP.13.14 LOOP.13.15

 LOOP.13.16 LOOP.13.17 LOOP.13.18 LOOP.13.19 LOOP.13.20 LOOP.13.21

 LOOP.13.22 LOOP.13.23 LOOP.13.24 LOOP.13.25 LOOP.13.26 LOOP.13.27

 LOOP.13.28 LOOP.13.29 LOOP.13.30 LOOP.13.31 LOOP.13.32 LOOP.13.33

 LOOP.13.34 LOOP.13.35 LOOP.13.36 LOOP.13.37 LOOP.13.38 LOOP.13.39

 LOOP.13.40 LOOP.13.41 LOOP.13.42 LOOP.13.43 LOOP.13.44 LOOP.13.45

 LOOP.13.46 LOOP.13.47 LOOP.13.52 LOOP.13.53 LOOP.13.54 LOOP.13.55

 LOOP.13.56 LOOP.13.57 LOOP.13.58 LOOP.13.59 LOOP.13.60 LOOP.13.61

 LOOP.13.62 LOOP.13.63 LOOP.13.64 LOOP.13.65 LOOP.13.66 LOOP.13.67

 LOOP.13.68 LOOP.13.69 LOOP.13.70 LOOP.13.71 LOOP.13.72 LOOP.13.73

 LOOP.13.74 LOOP.13.75 LOOP.13.76 LOOP.13.77 LOOP.13.78 LOOP.13.79

 LOOP.13.80 LOOP.13.81 LOOP.13.82 LOOP.13.83 LOOP.13.84 LOOP.13.85

 LOOP.13.86 LOOP.13.87 LOOP.13.88 LOOP.13.89 LOOP.13.90 LOOP.14.1

 LOOP.14.2 LOOP.14.3 LOOP.14.4 LOOP.14.5 LOOP.14.6 LOOP.14.7 LOOP.14.8

 LOOP.14.9 LOOP.14.10 LOOP.14.11 LOOP.14.12 LOOP.14.13 LOOP.14.14

 LOOP.14.15 LOOP.14.16 LOOP.14.17 LOOP.14.18 LOOP.14.19 LOOP.14.20

 LOOP.14.21 LOOP.14.22 LOOP.14.23 LOOP.14.24 LOOP.14.25 LOOP.14.26

 LOOP.14.27 LOOP.14.28 LOOP.14.29 LOOP.14.30 LOOP.14.31 LOOP.14.32

 LOOP.14.33 LOOP.14.34 LOOP.14.35 LOOP.14.36 LOOP.14.37 LOOP.14.38

 LOOP.14.39 LOOP.14.40 LOOP.14.41 LOOP.14.42 LOOP.14.43 LOOP.14.44

 LOOP.14.45 LOOP.14.46 LOOP.14.47 LOOP.14.48 LOOP.14.49 LOOP.15.30

 LOOP.15.31 LOOP.15.32 LOOP.15.33 LOOP.15.34 LOOP.15.35 LOOP.15.36

 LOOP.15.37 LOOP.15.38 LOOP.15.39 LOOP.15.40 LOOP.15.41 LOOP.15.42

 LOOP.15.43 LOOP.15.44 LOOP.15.45 LOOP.15.46 LOOP.15.47 LOOP.15.48

 LOOP.15.49 LOOP.15.50 LOOP.15.51 LOOP.15.52 LOOP.15.53 LOOP.15.54

 LOOP.15.55 LOOP.15.56 LOOP.15.57 LOOP.15.58 LOOP.15.59 LOOP.15.60

 LOOP.15.61 LOOP.15.62 LOOP.15.63 LOOP.15.64 LOOP.15.65 LOOP.15.66

 LOOP.15.67 LOOP.15.68 LOOP.15.69 LOOP.15.70 LOOP.15.71 LOOP.15.72

 LOOP.15.73 LOOP.15.74 LOOP.15.75 LOOP.16.30 LOOP.16.31 LOOP.16.32

 LOOP.16.33 LOOP.16.34 LOOP.16.35 LOOP.16.36 LOOP.16.37 LOOP.16.38

 LOOP.16.39 LOOP.16.40 LOOP.16.41 LOOP.16.42 LOOP.16.43 LOOP.16.44

 LOOP.16.45 LOOP.16.46 LOOP.16.47 LOOP.16.48 LOOP.16.49 LOOP.16.50

 LOOP.16.51 LOOP.16.52 LOOP.16.53 LOOP.16.54 LOOP.16.55 LOOP.16.56

 LOOP.16.57 LOOP.16.58 LOOP.16.59 LOOP.16.60 LOOP.16.61 LOOP.16.62

 LOOP.16.63 LOOP.16.64 LOOP.16.65 LOOP.16.66 LOOP.16.67 LOOP.16.68

 LOOP.16.69 LOOP.16.70 LOOP.16.71 LOOP.16.72 LOOP.16.73 LOOP.16.74

 LOOP.16.75 LOOP.17.1 LOOP.17.2 LOOP.17.3 LOOP.17.4 LOOP.17.5 LOOP.17.6

 LOOP.17.7 LOOP.17.8 LOOP.17.9 LOOP.17.10 LOOP.17.11 LOOP.17.12

 LOOP.17.13 LOOP.17.14 LOOP.17.20 LOOP.17.21 LOOP.17.22

 DEFCLASS-1-DEFCLASS-RETURNS-CLASS DEFCLASS-1-IS-IN-ITS-METACLASS

 DEFCLASS-1S-ARE-STANDARD-OBJECTS DEFCLASS-1-ALLOCATE-INSTANCE

 DEFCLASS-2-DEFCLASS-RETURNS-CLASS DEFCLASS-2-IS-IN-ITS-METACLASS

 DEFCLASS-2S-ARE-STANDARD-OBJECTS DEFCLASS-2-HAS-SLOT-NAMED-SLOT1

 DEFCLASS-2-HAS-SLOT-NAMED-SLOT2 DEFCLASS-2-HAS-SLOT-NAMED-SLOT3

 DEFCLASS-2-ALLOCATE-INSTANCE DEFCLASS-3-DEFCLASS-RETURNS-CLASS

 DEFCLASS-3-IS-IN-ITS-METACLASS DEFCLASS-3S-ARE-STANDARD-OBJECTS

 DEFCLASS-3-ALLOCATE-INSTANCE DEFCLASS-4-DEFCLASS-RETURNS-CLASS

 DEFCLASS-4-IS-IN-ITS-METACLASS DEFCLASS-4S-ARE-STANDARD-OBJECTS

 DEFCLASS-4-HAS-SLOT-NAMED-SLOT1 DEFCLASS-4-HAS-SLOT-NAMED-SLOT4

 DEFCLASS-4-ALLOCATE-INSTANCE

 CLASS-READERS/WRITERS/ACCESSORS-ARE-GENERIC-FUNCTIONS

 CLASS-ACCESSORS-HAVE-GENERIC-SETF-FUNCTIONS CLASS-01.1 CLASS-01.2

 CLASS-01.3 CLASS-02.1 CLASS-02.2 CLASS-02.3 CLASS-03.1 CLASS-03.2

 CLASS-03.3 CLASS-04.1 CLASS-04.2 CLASS-04.3 CLASS-04.4 CLASS-04.5

 CLASS-05.1 CLASS-06.1 CLASS-06.2 CLASS-07.1 CLASS-07.2 CLASS-07.3

 CLASS-07.4 CLASS-07.5 CLASS-07.6 CLASS-07.7 CLASS-07.8 CLASS-07.9

 CLASS-07.10 CLASS-07.11 CLASS-07.12 CLASS-08.1 CLASS-09.1 CLASS-09.2

 CLASS-09.3 CLASS-09.4 CLASS-10.1 CLASS-10.2 CLASS-11.1 CLASS-11.2

 CLASS-12.1 CLASS-12.2 CLASS-13.1 CLASS-14.1 CLASS-15.2 CLASS-15.3

 CLASS-15.4 CLASS-15.5 CLASS-15.6 CLASS-15.7 CLASS-16.1 CLASS-16.2

 CLASS-16.3 CLASS-17.1 CLASS-17.2 CLASS-17.3 CLASS-18.1 CLASS-18.2

 CLASS-18.3 CLASS-18.4 CLASS-18.5 CLASS-19.1 CLASS-19.2 CLASS-19.3

 CLASS-20.1 CLASS-20.2 CLASS-20.3 CLASS-21.1 CLASS-21.2 CLASS-21.3

 CLASS-21.4 CLASS-21.5 CLASS-22.1 CLASS-23.1 CLASS-23.2 CLASS-23.3

 CLASS-23.4 CLASS-24.1 CLASS-24.2 CLASS-24.3 CLASS-24.4 CLASS-25.1

 CLASS-25.2 CLASS-25.3 CLASS-25.4 CLASS-25.5 CLASS-25.6 CLASS-26.1

 CLASS-27.1 CLASS-27.2 CLASS-27.3 CLASS-28.1 CLASS-28.2 CLASS-28.3

 CLASS-0201.1 CLASS-0202.1 CLASS-0203.1 CLASS-0203.2 CLASS-0205A.1

 CLASS-0205B.1 CLASS-0206.1 CLASS-0207.1 CLASS-0208.1

 CLASS-REDEFINITION.1 CLASS-REDEFINITION.2 CLASS-REDEFINITION.3

 CLASS-0211.1 CLASS-0212.1 CLASS-0212.2 CLASS-0212.3 CLASS-0212.4

 CLASS-0212.5 CLASS-0213.1 CLASS-0213.2 CLASS-0214.1 CLASS-0214.2

 CLASS-0215.1 CLASS-0215.2 CLASS-0216.1 CLASS-0216.2 CLASS-0217.1

 CLASS-0217.2 CLASS-0217.3 CLASS-0217.4 CLASS-0218.1 CLASS-0218.2

 CLASS-0219.1 CLASS-0219.2 CLASS-0220.1 CLASS-0220.2 CLASS-0220.3

 CLASS-0220.4 CLASS-0221.1 CLASS-0221.2 CLASS-0221.3 CLASS-0222.1

 CLASS-0222.2 CLASS-0223.1 CLASS-0301.1 CLASS-0302.1 CLASS-0303.1

 CLASS-0304.1 CLASS-0305.1 CLASS-0306.1 CLASS-0306.2 CLASS-0307.1

 CLASS-0308.1 CLASS-0309.1 CLASS-0310.1 CLASS-0311.1 DEFCLASS.ERROR.1

 DEFCLASS.ERROR.2 DEFCLASS.ERROR.3 DEFCLASS.ERROR.4 DEFCLASS.ERROR.5

 DEFCLASS.ERROR.6 DEFCLASS.ERROR.7 DEFCLASS.ERROR.8 DEFCLASS.ERROR.9

 DEFCLASS.ERROR.10 DEFCLASS.ERROR.11 DEFCLASS.ERROR.12 DEFCLASS.ERROR.13

 DEFCLASS.ERROR.14 DEFCLASS.ERROR.15 DEFCLASS.ERROR.16 DEFCLASS.ERROR.17

 DEFCLASS.ERROR.18 DEFCLASS.ERROR.19 DEFCLASS.ERROR.20 DEFCLASS.ERROR.21

 DEFCLASS.ERROR.22 DEFCLASS.ERROR.23 DEFCLASS.ERROR.24;;; Warning: Class G71487 has been forward referenced.



 DEFCLASS.FORWARD-REF.1;;; Warning: Class G71489 has been forward referenced.

;;; Warning: Class G71490 has been forward referenced.

 DEFCLASS.FORWARD-REF.2;;; Warning: Class G71492 has been forward referenced.

;;; Warning: Class G71493 has been forward referenced.

 DEFCLASS.FORWARD-REF.3;;; Warning: Class G71498 has been forward referenced.

;;; Warning: Class G71499 has been forward referenced.



 DEFCLASS.FORWARD-REF.4 ENSURE-GENERIC-FUNCTION.1

 ENSURE-GENERIC-FUNCTION.2 ENSURE-GENERIC-FUNCTION.3

 ENSURE-GENERIC-FUNCTION.4 ENSURE-GENERIC-FUNCTION.5

 ENSURE-GENERIC-FUNCTION.6 ENSURE-GENERIC-FUNCTION.7

 ENSURE-GENERIC-FUNCTION.8 ENSURE-GENERIC-FUNCTION.9

 ENSURE-GENERIC-FUNCTION.10 ENSURE-GENERIC-FUNCTION.11

 ENSURE-GENERIC-FUNCTION.12 ENSURE-GENERIC-FUNCTION.13

 ENSURE-GENERIC-FUNCTION.14 ENSURE-GENERIC-FUNCTION.ERROR.1

 ENSURE-GENERIC-FUNCTION.ERROR.2 ALLOCATE-INSTANCE.1 ALLOCATE-INSTANCE.2

 ALLOCATE-INSTANCE.3 ALLOCATE-INSTANCE.4 ALLOCATE-INSTANCE.5

 ALLOCATE-INSTANCE.ORDER.1 ALLOCATE-INSTANCE.ERROR.1

 REINITIALIZE-INSTANCE.1 REINITIALIZE-INSTANCE.2 REINITIALIZE-INSTANCE.3

 REINITIALIZE-INSTANCE.4 REINITIALIZE-INSTANCE.5 REINITIALIZE-INSTANCE.6

 REINITIALIZE-INSTANCE.7 REINITIALIZE-INSTANCE.8 REINITIALIZE-INSTANCE.9

 REINITIALIZE-INSTANCE.10 REINITIALIZE-INSTANCE.ORDER.1

 REINITIALIZE-INSTANCE.ERROR.1 REINITIALIZE-INSTANCE.ERROR.2

 SHARED-INITIALIZE.1.1 SHARED-INITIALIZE.1.2 SHARED-INITIALIZE.1.3

 SHARED-INITIALIZE.1.4 SHARED-INITIALIZE.1.5 SHARED-INITIALIZE.1.6

 SHARED-INITIALIZE.1.7 SHARED-INITIALIZE.1.8 SHARED-INITIALIZE.1.9

 SHARED-INITIALIZE.1.10 SHARED-INITIALIZE.2.1 SHARED-INITIALIZE.2.2

 SHARED-INITIALIZE.2.3 SHARED-INITIALIZE.2.4 SHARED-INITIALIZE.2.5

 SHARED-INITIALIZE.2.6 SHARED-INITIALIZE.3.1 SHARED-INITIALIZE.4.1

 SHARED-INITIALIZE.4.2 SHARED-INITIALIZE.4.3 SHARED-INITIALIZE.4.4

 SHARED-INITIALIZE.4.5 SHARED-INITIALIZE.4.6 SHARED-INITIALIZE.4.7

 SHARED-INITIALIZE.5.1 SHARED-INITIALIZE.5.2 SHARED-INITIALIZE.5.3

 SHARED-INITIALIZE.5.4 SHARED-INITIALIZE.6.1 SHARED-INITIALIZE.6.2

 SHARED-INITIALIZE.6.3 SHARED-INITIALIZE.6.4 SHARED-INITIALIZE.6.5

 SHARED-INITIALIZE.6.6 SHARED-INITIALIZE.6.7 SHARED-INITIALIZE.6.8

 SHARED-INITIALIZE.6.9 SHARED-INITIALIZE.7.1 SHARED-INITIALIZE.7.2

 SHARED-INITIALIZE.8.1 SHARED-INITIALIZE.8.2 SHARED-INITIALIZE.8.3

 SHARED-INITIALIZE.9.1 SHARED-INITIALIZE.ORDER.1

 SHARED-INITIALIZE.ERROR.1 SHARED-INITIALIZE.ERROR.2

 SHARED-INITIALIZE.ERROR.3 SHARED-INITIALIZE.ERROR.4 CHANGE-CLASS.1.1

 CHANGE-CLASS.1.2 CHANGE-CLASS.1.3 CHANGE-CLASS.1.4 CHANGE-CLASS.1.5

 CHANGE-CLASS.1.6 CHANGE-CLASS.1.7 CHANGE-CLASS.1.8 CHANGE-CLASS.1.9

 CHANGE-CLASS.1.10 CHANGE-CLASS.1.11 CHANGE-CLASS.1.12 CHANGE-CLASS.2.1

 CHANGE-CLASS.2.2 CHANGE-CLASS.2.3 CHANGE-CLASS.3.1 CHANGE-CLASS.3.2

 CHANGE-CLASS.4.1 CHANGE-CLASS.4.2 CHANGE-CLASS.4.3 CHANGE-CLASS.4.4

 CHANGE-CLASS.4.5 CHANGE-CLASS.5 CHANGE-CLASS.6.1 CHANGE-CLASS.6.2

 CHANGE-CLASS.7.1 CHANGE-CLASS.7.2 CHANGE-CLASS.7.3 CHANGE-CLASS.7.4

 CHANGE-CLASS.7.5 CHANGE-CLASS.7.6 CHANGE-CLASS.8.1 CHANGE-CLASS.8.2

 CHANGE-CLASS.8.3 CHANGE-CLASS.ERROR.1 CHANGE-CLASS.ERROR.2

 CHANGE-CLASS.ERROR.3 CHANGE-CLASS.ERROR.4 CHANGE-CLASS.ERROR.5

 CHANGE-CLASS.ERROR.6 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.1

 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.2

 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.3

 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.4

 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.5

 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.6

 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.7

 UPDATE-INSTANCE-FOR-DIFFERENT-CLASS.8 SLOT-BOUNDP.1 SLOT-BOUNDP.2

 SLOT-BOUNDP.3 SLOT-BOUNDP.4 SLOT-BOUNDP.5 SLOT-BOUNDP.ORDER.1

 SLOT-BOUNDP.ERROR.1 SLOT-BOUNDP.ERROR.2 SLOT-BOUNDP.ERROR.3

 SLOT-BOUNDP.ERROR.4 SLOT-BOUNDP.ERROR.5 SLOT-EXISTS-P.1 SLOT-EXISTS-P.2

 SLOT-EXISTS-P.3 SLOT-EXISTS-P.4 SLOT-EXISTS-P.5 SLOT-EXISTS-P.6

 SLOT-EXISTS-P.7 SLOT-EXISTS-P.8 SLOT-EXISTS-P.9 SLOT-EXISTS-P.10

 SLOT-EXISTS-P.11 SLOT-EXISTS-P.12 SLOT-EXISTS-P.13 SLOT-EXISTS-P.14

 SLOT-EXISTS-P.15 SLOT-EXISTS-P.16 SLOT-EXISTS-P.ORDER.1

 SLOT-EXISTS-P.ORDER.2 SLOT-EXISTS-P.ORDER.3 SLOT-EXISTS-P.ERROR.1

 SLOT-EXISTS-P.ERROR.2 SLOT-EXISTS-P.ERROR.3 SLOT-EXISTS-P.ERROR.4

 SLOT-MAKUNBOUND.1 SLOT-MAKUNBOUND.2 SLOT-MAKUNBOUND.ORDER.1

 SLOT-MAKUNBOUND.ORDER.2 SLOT-MAKUNBOUND.ERROR.1 SLOT-MAKUNBOUND.ERROR.2

 SLOT-MAKUNBOUND.ERROR.3 SLOT-MAKUNBOUND.ERROR.4 SLOT-MISSING.1

 SLOT-MISSING.2 SLOT-MISSING.3 SLOT-MISSING.4 SLOT-MISSING.5

 SLOT-MISSING.6 SLOT-MISSING.7 SLOT-MISSING.8 SLOT-UNBOUND.1

 SLOT-UNBOUND.2 SLOT-UNBOUND.3 SLOT-UNBOUND.4 SLOT-UNBOUND.5

 SLOT-UNBOUND.6 SLOT-VALUE.1 SLOT-VALUE.2 SLOT-VALUE.ORDER.1

 SLOT-VALUE.ORDER.2 SLOT-VALUE.ERROR.1 SLOT-VALUE.ERROR.2

 SLOT-VALUE.ERROR.3 SLOT-VALUE.ERROR.4 SLOT-VALUE.ERROR.5

 SLOT-VALUE.ERROR.6 METHOD-QUALIFIERS.1 METHOD-QUALIFIERS.2

 METHOD-QUALIFIERS.3 METHOD-QUALIFIERS.4 METHOD-QUALIFIERS.ERROR.1

 METHOD-QUALIFIERS.ERROR.2 NO-APPLICABLE-METHOD.1 NO-NEXT-METHOD.1

 NO-NEXT-METHOD.2 REMOVE-METHOD.1 REMOVE-METHOD.2 REMOVE-METHOD.3

 REMOVE-METHOD.4 REMOVE-METHOD.5 REMOVE-METHOD.6 REMOVE-METHOD.7

 REMOVE-METHOD.8 REMOVE-METHOD.9 REMOVE-METHOD.10 REMOVE-METHOD.11

 MAKE-INSTANCE.ERROR.1 MAKE-INSTANCE.ERROR.2 MAKE-INSTANCE.ERROR.3

 MAKE-INSTANCE.ERROR.4 MAKE-INSTANCE.ERROR.5 MAKE-INSTANCE.ERROR.6

 MAKE-INSTANCE.1 MAKE-INSTANCE.2 MAKE-INSTANCE.ORDER.1

 MAKE-INSTANCE.ORDER.2 MAKE-INSTANCE.ORDER.3 MAKE-INSTANCES-OBSOLETE.1

 MAKE-INSTANCES-OBSOLETE.2 MAKE-INSTANCES-OBSOLETE.ERROR.1

 MAKE-INSTANCES-OBSOLETE.ERROR.2 MAKE-LOAD-FORM.1 MAKE-LOAD-FORM.2

 MAKE-LOAD-FORM.3 MAKE-LOAD-FORM.4 MAKE-LOAD-FORM.5 MAKE-LOAD-FORM.6

 MAKE-LOAD-FORM.7 MAKE-LOAD-FORM.8 MAKE-LOAD-FORM.9 MAKE-LOAD-FORM.10

 MAKE-LOAD-FORM.11 MAKE-LOAD-FORM.12 MAKE-LOAD-FORM.13 MAKE-LOAD-FORM.14

 MAKE-LOAD-FORM.15 MAKE-LOAD-FORM.ERROR.1 MAKE-LOAD-FORM.ERROR.2

 MAKE-LOAD-FORM-SAVING-SLOTS.1 MAKE-LOAD-FORM-SAVING-SLOTS.2

 MAKE-LOAD-FORM-SAVING-SLOTS.3 MAKE-LOAD-FORM-SAVING-SLOTS.4

 MAKE-LOAD-FORM-SAVING-SLOTS.5 MAKE-LOAD-FORM-SAVING-SLOTS.6

 MAKE-LOAD-FORM-SAVING-SLOTS.7 MAKE-LOAD-FORM-SAVING-SLOTS.8

 MAKE-LOAD-FORM-SAVING-SLOTS.9 MAKE-LOAD-FORM-SAVINGS-SLOTS.10

 MAKE-LOAD-FORM-SAVINGS-SLOTS.11 MAKE-LOAD-FORM-SAVINGS-SLOTS.12

 MAKE-LOAD-FORM-SAVING-SLOTS.ERROR.1 MAKE-LOAD-FORM-SAVING-SLOTS.ERROR.2

 MAKE-LOAD-FORM-SAVING-SLOTS.ERROR.3 WITH-ACCESSORS.1 WITH-ACCESSORS.2

 WITH-ACCESSORS.3 WITH-ACCESSORS.4 WITH-ACCESSORS.5 WITH-ACCESSORS.6

 WITH-ACCESSORS.7 WITH-ACCESSORS.8 WITH-ACCESSORS.9 WITH-ACCESSORS.10

 WITH-ACCESSORS.11 WITH-ACCESSORS.12 WITH-ACCESSORS.13 WITH-ACCESSORS.14

 WITH-ACCESSORS.15 WITH-SLOTS.1 WITH-SLOTS.2 WITH-SLOTS.3 WITH-SLOTS.4

 WITH-SLOTS.5 WITH-SLOTS.6 WITH-SLOTS.7 WITH-SLOTS.8 WITH-SLOTS.9

 WITH-SLOTS.10 WITH-SLOTS.11 WITH-SLOTS.12 WITH-SLOTS.13 WITH-SLOTS.14

 WITH-SLOTS.15 WITH-SLOTS.16 WITH-SLOTS.17 WITH-SLOTS.18 WITH-SLOTS.19

 WITH-SLOTS.20 WITH-SLOTS.21 DEFGENERIC.ERROR.1 DEFGENERIC.ERROR.2

 DEFGENERIC.ERROR.3 DEFGENERIC.ERROR.4 DEFGENERIC.ERROR.5

 DEFGENERIC.ERROR.6 DEFGENERIC.ERROR.7 DEFGENERIC.ERROR.8

 DEFGENERIC.ERROR.9 DEFGENERIC.ERROR.10 DEFGENERIC.ERROR.11

 DEFGENERIC.ERROR.12 DEFGENERIC.ERROR.13 DEFGENERIC.ERROR.14

 DEFGENERIC.ERROR.15 DEFGENERIC.ERROR.16 DEFGENERIC.ERROR.17

 DEFGENERIC.ERROR.18 DEFGENERIC.ERROR.19

Test DEFGENERIC.ERROR.20 failed

Form: (SIGNALS-ERROR

       (LET ((FN

              (DEFGENERIC DEFGENERIC-ERROR-FN.20

                          (X &KEY)

                          (:METHOD ((X NUMBER) &KEY FOO) (LIST X FOO))

                          (:METHOD ((X SYMBOL) &KEY BAR) (LIST X BAR)))))

         (FUNCALL FN 1 :BAR 'A))

       PROGRAM-ERROR)

Expected value: T

Actual values: NIL

               (1 NIL).

Test DEFGENERIC.ERROR.21 failed

Form: (SIGNALS-ERROR

       (LET ((FN

              (DEFGENERIC DEFGENERIC-ERROR-FN.21

                          (X &KEY)

                          (:METHOD ((X NUMBER) &KEY FOO &ALLOW-OTHER-KEYS)

                           (LIST X FOO))

                          (:METHOD ((X SYMBOL) &KEY BAR) (LIST X BAR)))))

         (FUNCALL FN 'X :FOO 'A))

       PROGRAM-ERROR)

Expected value: T

Actual values: NIL

               (X NIL).

 DEFGENERIC.ERROR.22 DEFGENERIC.1 DEFGENERIC.2 DEFGENERIC.3 DEFGENERIC.4

 DEFGENERIC.5 DEFGENERIC.6 DEFGENERIC.7 DEFGENERIC.8 DEFGENERIC.9

 DEFGENERIC.10 DEFGENERIC.11 DEFGENERIC.12 DEFGENERIC.13 DEFGENERIC.14

 DEFGENERIC.15 DEFGENERIC.16 DEFGENERIC.17 DEFGENERIC.18 DEFGENERIC.19

 DEFGENERIC.20 DEFGENERIC.21 DEFGENERIC.22 DEFGENERIC.23 DEFGENERIC.24

 DEFGENERIC.25 DEFGENERIC.26 DEFGENERIC.28 DEFGENERIC.29 DEFGENERIC.31

 DEFGENERIC.32 DEFGENERIC.33 DEFGENERIC.34 DEFGENERIC.35

 DEFGENERIC-METHOD-COMBINATION.+.1 DEFGENERIC-METHOD-COMBINATION.+.2

 DEFGENERIC-METHOD-COMBINATION.+.3 DEFGENERIC-METHOD-COMBINATION.+.4

 DEFGENERIC-METHOD-COMBINATION.+.5 DEFGENERIC-METHOD-COMBINATION.+.6

 DEFGENERIC-METHOD-COMBINATION.+.7 DEFGENERIC-METHOD-COMBINATION.+.8

 DEFGENERIC-METHOD-COMBINATION.+.9 DEFGENERIC-METHOD-COMBINATION.+.10

 DEFGENERIC-METHOD-COMBINATION.+.11 DEFGENERIC-METHOD-COMBINATION.+.12

 DEFGENERIC-METHOD-COMBINATION.APPEND.1

 DEFGENERIC-METHOD-COMBINATION.APPEND.2

 DEFGENERIC-METHOD-COMBINATION.APPEND.3

 DEFGENERIC-METHOD-COMBINATION.APPEND.4

 DEFGENERIC-METHOD-COMBINATION.APPEND.5

 DEFGENERIC-METHOD-COMBINATION.APPEND.6

 DEFGENERIC-METHOD-COMBINATION.APPEND.7

 DEFGENERIC-METHOD-COMBINATION.APPEND.8

 DEFGENERIC-METHOD-COMBINATION.APPEND.9

 DEFGENERIC-METHOD-COMBINATION.APPEND.10

 DEFGENERIC-METHOD-COMBINATION.APPEND.11

 DEFGENERIC-METHOD-COMBINATION.APPEND.12

 DEFGENERIC-METHOD-COMBINATION.APPEND.13

 DEFGENERIC-METHOD-COMBINATION.NCONC.1

 DEFGENERIC-METHOD-COMBINATION.NCONC.2

 DEFGENERIC-METHOD-COMBINATION.NCONC.3

 DEFGENERIC-METHOD-COMBINATION.NCONC.4

 DEFGENERIC-METHOD-COMBINATION.NCONC.5

 DEFGENERIC-METHOD-COMBINATION.NCONC.6

 DEFGENERIC-METHOD-COMBINATION.NCONC.7

 DEFGENERIC-METHOD-COMBINATION.NCONC.8

 DEFGENERIC-METHOD-COMBINATION.NCONC.9

 DEFGENERIC-METHOD-COMBINATION.NCONC.10

 DEFGENERIC-METHOD-COMBINATION.NCONC.11

 DEFGENERIC-METHOD-COMBINATION.NCONC.12

 DEFGENERIC-METHOD-COMBINATION.LIST.1

 DEFGENERIC-METHOD-COMBINATION.LIST.2

 DEFGENERIC-METHOD-COMBINATION.LIST.3

 DEFGENERIC-METHOD-COMBINATION.LIST.4

 DEFGENERIC-METHOD-COMBINATION.LIST.5

 DEFGENERIC-METHOD-COMBINATION.LIST.6

 DEFGENERIC-METHOD-COMBINATION.LIST.7

 DEFGENERIC-METHOD-COMBINATION.LIST.8

 DEFGENERIC-METHOD-COMBINATION.LIST.9

 DEFGENERIC-METHOD-COMBINATION.LIST.10

 DEFGENERIC-METHOD-COMBINATION.LIST.11

 DEFGENERIC-METHOD-COMBINATION.LIST.12

 DEFGENERIC-METHOD-COMBINATION.MAX.1 DEFGENERIC-METHOD-COMBINATION.MAX.2

 DEFGENERIC-METHOD-COMBINATION.MAX.3 DEFGENERIC-METHOD-COMBINATION.MAX.4

 DEFGENERIC-METHOD-COMBINATION.MAX.5 DEFGENERIC-METHOD-COMBINATION.MAX.6

 DEFGENERIC-METHOD-COMBINATION.MAX.7 DEFGENERIC-METHOD-COMBINATION.MAX.8

 DEFGENERIC-METHOD-COMBINATION.MAX.9

 DEFGENERIC-METHOD-COMBINATION.MAX.10

 DEFGENERIC-METHOD-COMBINATION.MAX.11

 DEFGENERIC-METHOD-COMBINATION.MAX.12

 DEFGENERIC-METHOD-COMBINATION.MIN.1 DEFGENERIC-METHOD-COMBINATION.MIN.2

 DEFGENERIC-METHOD-COMBINATION.MIN.3 DEFGENERIC-METHOD-COMBINATION.MIN.4

 DEFGENERIC-METHOD-COMBINATION.MIN.5 DEFGENERIC-METHOD-COMBINATION.MIN.6

 DEFGENERIC-METHOD-COMBINATION.MIN.7 DEFGENERIC-METHOD-COMBINATION.MIN.8

 DEFGENERIC-METHOD-COMBINATION.MIN.9

 DEFGENERIC-METHOD-COMBINATION.MIN.10

 DEFGENERIC-METHOD-COMBINATION.MIN.11

 DEFGENERIC-METHOD-COMBINATION.MIN.12

 DEFGENERIC-METHOD-COMBINATION.AND.1 DEFGENERIC-METHOD-COMBINATION.AND.2

 DEFGENERIC-METHOD-COMBINATION.AND.3 DEFGENERIC-METHOD-COMBINATION.AND.4

 DEFGENERIC-METHOD-COMBINATION.AND.5 DEFGENERIC-METHOD-COMBINATION.AND.6

 DEFGENERIC-METHOD-COMBINATION.AND.7 DEFGENERIC-METHOD-COMBINATION.AND.8

 DEFGENERIC-METHOD-COMBINATION.AND.9

 DEFGENERIC-METHOD-COMBINATION.AND.10

 DEFGENERIC-METHOD-COMBINATION.AND.11

 DEFGENERIC-METHOD-COMBINATION.AND.12 DEFGENERIC-METHOD-COMBINATION.OR.1

 DEFGENERIC-METHOD-COMBINATION.OR.2 DEFGENERIC-METHOD-COMBINATION.OR.3

 DEFGENERIC-METHOD-COMBINATION.OR.4 DEFGENERIC-METHOD-COMBINATION.OR.5

 DEFGENERIC-METHOD-COMBINATION.OR.6 DEFGENERIC-METHOD-COMBINATION.OR.7

 DEFGENERIC-METHOD-COMBINATION.OR.8 DEFGENERIC-METHOD-COMBINATION.OR.9

 DEFGENERIC-METHOD-COMBINATION.OR.10 DEFGENERIC-METHOD-COMBINATION.OR.11

 DEFGENERIC-METHOD-COMBINATION.OR.12

 DEFGENERIC-METHOD-COMBINATION.PROGN.1

 DEFGENERIC-METHOD-COMBINATION.PROGN.2

 DEFGENERIC-METHOD-COMBINATION.PROGN.3

 DEFGENERIC-METHOD-COMBINATION.PROGN.4

 DEFGENERIC-METHOD-COMBINATION.PROGN.4A

 DEFGENERIC-METHOD-COMBINATION.PROGN.5

 DEFGENERIC-METHOD-COMBINATION.PROGN.5A

 DEFGENERIC-METHOD-COMBINATION.PROGN.6

 DEFGENERIC-METHOD-COMBINATION.PROGN.6A

 DEFGENERIC-METHOD-COMBINATION.PROGN.7

 DEFGENERIC-METHOD-COMBINATION.PROGN.7A

 DEFGENERIC-METHOD-COMBINATION.PROGN.8

 DEFGENERIC-METHOD-COMBINATION.PROGN.9

 DEFGENERIC-METHOD-COMBINATION.PROGN.10

 DEFGENERIC-METHOD-COMBINATION.PROGN.11

 DEFGENERIC-METHOD-COMBINATION.PROGN.12 FIND-CLASS.1 FIND-CLASS.2

 FIND-CLASS.3 FIND-CLASS.4 FIND-CLASS.5 FIND-CLASS.6 FIND-CLASS.7

 FIND-CLASS.8 FIND-CLASS.9 FIND-CLASS.10 FIND-CLASS.11 FIND-CLASS.12

 FIND-CLASS.13 FIND-CLASS.14 FIND-CLASS.15 FIND-CLASS.16 FIND-CLASS.17

 FIND-CLASS.18 FIND-CLASS.19 FIND-CLASS.20 FIND-CLASS.21 FIND-CLASS.22

 FIND-CLASS.23 FIND-CLASS.ERROR.1 FIND-CLASS.ERROR.2 NEXT-METHOD-P.1

 NEXT-METHOD-P.2 NEXT-METHOD-P.3 NEXT-METHOD-P.4 NEXT-METHOD-P.5

 NEXT-METHOD-P.6 NEXT-METHOD-P.7 NEXT-METHOD-P.8 NEXT-METHOD-P.9

 NEXT-METHOD-P.10 NEXT-METHOD-P.ERROR.1 CALL-NEXT-METHOD.1

 CALL-NEXT-METHOD.2 CALL-NEXT-METHOD.3 CALL-NEXT-METHOD.4

 CALL-NEXT-METHOD.5 CALL-NEXT-METHOD.6 CALL-NEXT-METHOD.7

 CALL-NEXT-METHOD.8 CALL-NEXT-METHOD.9 CALL-NEXT-METHOD.10

 CALL-NEXT-METHOD.11

Test CALL-NEXT-METHOD.ERROR.1 failed

Form: (LOCALLY

       (DECLARE (OPTIMIZE (SAFETY 3)))

       (HANDLER-CASE

        (EVAL

         '(LOCALLY (DECLARE (OPTIMIZE (SAFETY 3))) (CNM-ORDER-ERROR-GF-01 0)))

        (ERROR NIL :ERROR)))

Expected value: :ERROR

Actual value: NIL.

Test CALL-NEXT-METHOD.ERROR.2 failed

Form: (LOCALLY

       (DECLARE (OPTIMIZE (SAFETY 3)))

       (HANDLER-CASE

        (EVAL

         '(LOCALLY (DECLARE (OPTIMIZE (SAFETY 3))) (CNM-ORDER-ERROR-GF-02 0)))

        (ERROR NIL :ERROR)))

Expected value: :ERROR

Actual value: :BAD.

 COMPUTE-APPLICABLE-METHODS.1 COMPUTE-APPLICABLE-METHODS.2

 COMPUTE-APPLICABLE-METHODS.3 COMPUTE-APPLICABLE-METHODS.4

 COMPUTE-APPLICABLE-METHODS.5 COMPUTE-APPLICABLE-METHODS.6

 COMPUTE-APPLICABLE-METHODS.7 COMPUTE-APPLICABLE-METHODS.ERROR.1

 COMPUTE-APPLICABLE-METHODS.ERROR.2 COMPUTE-APPLICABLE-METHODS.ERROR.3

 DEFINE-METHOD-COMBINATION-01.1 DEFINE-METHOD-COMBINATION-01.2

 DEFINE-METHOD-COMBINATION-01.3 DEFINE-METHOD-COMBINATION-01.4

 DEFINE-METHOD-COMBINATION-02.1 DEFINE-METHOD-COMBINATION-03.1

 DEFINE-METHOD-COMBINATION-03.2 DEFINE-METHOD-COMBINATION-03.3

 DEFINE-METHOD-COMBINATION-04.1 DEFINE-METHOD-COMBINATION-04.2

 DEFINE-METHOD-COMBINATION-04.3 DEFINE-METHOD-COMBINATION-05.1

 DEFINE-METHOD-COMBINATION-07.1 FIND-METHOD.1 FIND-METHOD.2

 FIND-METHOD.3 FIND-METHOD.4 FIND-METHOD.5 FIND-METHOD.6 FIND-METHOD.7

 FIND-METHOD.8 FIND-METHOD.9 FIND-METHOD.ERROR.1 FIND-METHOD.ERROR.2

 FIND-METHOD.ERROR.3 FIND-METHOD.ERROR.4 FIND-METHOD.ERROR.5

 FIND-METHOD.ERROR.6 FIND-METHOD.ERROR.7 FIND-METHOD.ERROR.8

 FIND-METHOD.ERROR.9 FIND-METHOD.ERROR.10 ADD-METHOD.ERROR.1

 ADD-METHOD.ERROR.2 ADD-METHOD.ERROR.3 ADD-METHOD.ERROR.4

 ADD-METHOD.ERROR.5 ADD-METHOD.ERROR.6 ADD-METHOD.ERROR.7

 ADD-METHOD.ERROR.8 ADD-METHOD.1 ADD-METHOD.2 CLASS-NAME.1 CLASS-NAME.2

 SETF-CLASS-NAME.1 SETF-CLASS-NAME.2 CLASS-NAME.ERROR.1

 CLASS-NAME.ERROR.2 CLASS-OF.ERROR.1 CLASS-OF.ERROR.2 UNBOUND-SLOT.1

 UNBOUND-SLOT.2 DEFMETHOD.1 DEFMETHOD.2 DEFMETHOD.3 DEFMETHOD.4

 DEFMETHOD.5 DEFMETHOD.6 DEFMETHOD.7 DEFMETHOD.8 DEFMETHOD.9

 DEFMETHOD.10 DEFMETHOD.11 DEFMETHOD.ERROR.1 DEFMETHOD.ERROR.2

 DEFMETHOD.ERROR.3 DEFMETHOD.ERROR.4 DEFMETHOD.ERROR.5 DEFMETHOD.ERROR.6

 DEFMETHOD.ERROR.7 DEFMETHOD.ERROR.8 DEFMETHOD.ERROR.9

 DEFMETHOD.ERROR.10 DEFMETHOD.ERROR.11 DEFMETHOD.ERROR.12

 DEFMETHOD.ERROR.13

Test DEFMETHOD.ERROR.14 failed

Form: (LET ((SYM (GENSYM)))

        (EVAL

         (SI:QUASIQUOTE

          (LOCALLY

           (DECLARE (OPTIMIZE SAFETY))

           (DEFMETHOD (SI:UNQUOTE SYM) ((X T) &KEY) X))))

        (VALUES

         (EVAL

          (SI:QUASIQUOTE (SIGNALS-ERROR ((SI:UNQUOTE SYM)) PROGRAM-ERROR)))

         (EVAL

          (SI:QUASIQUOTE (SIGNALS-ERROR ((SI:UNQUOTE SYM) 1 2) PROGRAM-ERROR)))

         (EVAL

          (SI:QUASIQUOTE

           (SIGNALS-ERROR ((SI:UNQUOTE SYM) 1 :BOGUS T) PROGRAM-ERROR)))

         (EVAL

          (SI:QUASIQUOTE

           (SIGNALS-ERROR

            ((SI:UNQUOTE SYM) 1 :ALLOW-OTHER-KEYS NIL :ALLOW-OTHER-KEYS T

             :BOGUS T)

            PROGRAM-ERROR)))))

Expected values: T

                 T

                 T

                 T

Actual values: T

               T

               NIL

               NIL.

Test DEFMETHOD.ERROR.15 failed

Form: (LET ((SYM (GENSYM)))

        (EVAL

         (SI:QUASIQUOTE

          (LOCALLY

           (DECLARE (OPTIMIZE SAFETY))

           (DEFMETHOD (SI:UNQUOTE SYM) ((X T) &KEY Y) X))))

        (VALUES

         (EVAL

          (SI:QUASIQUOTE

           (SIGNALS-ERROR ((SI:UNQUOTE SYM) 1 :BOGUS T) PROGRAM-ERROR)))

         (EVAL

          (SI:QUASIQUOTE

           (SIGNALS-ERROR ((SI:UNQUOTE SYM) 1 :Y) PROGRAM-ERROR)))

         (EVAL

          (SI:QUASIQUOTE

           (SIGNALS-ERROR ((SI:UNQUOTE SYM) 1 3 NIL) PROGRAM-ERROR)))))

Expected values: T

                 T

                 T

Actual values: NIL

               T

               NIL.

 CONDITION.1 CONDITION.2 CONDITION.3 CELL-ERROR-NAME.1 CELL-ERROR-NAME.2

 CELL-ERROR-NAME.3 CELL-ERROR-NAME.4 CELL-ERROR-NAME.5 CELL-ERROR-NAME.6

 CELL-ERROR-NAME.ERROR.1 CELL-ERROR-NAME.ERROR.2 ASSERT.1 ASSERT.2

 ASSERT.3 ASSERT.3A ASSERT.4 ASSERT.5 ASSERT.6 ASSERT.7 ASSERT.8

 ASSERT.9 ASSERT.10 ASSERT.11 ERROR.1 ERROR.2 ERROR.3 ERROR.4 ERROR.5

 ERROR.6 ERROR.7 ERROR.8 ERROR.9 ERROR.10 ERROR.11 ERROR.12 CERROR.1

 CERROR.2 CERROR.2A CERROR.3 CERROR.4 CERROR.4A CERROR.5 CERROR.6

 CERROR.ERROR.1 CERROR.ERROR.2 CHECK-TYPE.1 CHECK-TYPE.2 CHECK-TYPE.3

 CHECK-TYPE.4 CHECK-TYPE.5 CHECK-TYPE.6 CHECK-TYPE.7 CHECK-TYPE.8

 CHECK-TYPE.9 WARN.1 WARN.2 WARN.3 WARN.4 WARN.5 WARN.6 WARN.7 WARN.8

 WARN.9 WARN.10 WARN.11 WARN.12 WARN.13 WARN.14 WARN.15 WARN.16 WARN.17

 WARN.18 WARN.19 INVOKE-DEBUGGER.1 INVOKE-DEBUGGER.ERROR.1

 INVOKE-DEBUGGER.ERROR.2 INVOKE-DEBUGGER.ERROR.3 INVOKE-DEBUGGER.ERROR.4

 INVOKE-DEBUGGER.ERROR.5 HANDLER-BIND.1 HANDLER-BIND.2 HANDLER-BIND.3

 HANDLER-BIND.4 HANDLER-BIND.5 HANDLER-BIND.6 HANDLER-BIND.7

 HANDLER-BIND.8 HANDLER-BIND.9 HANDLER-BIND.10 HANDLER-BIND.11

 HANDLER-BIND.12 HANDLER-BIND.13 HANDLER-BIND.14 HANDLER-BIND.15

 HANDLER-BIND.16 HANDLER-BIND.17 HANDLER-CASE.1 HANDLER-CASE.2

 HANDLER-CASE.3 HANDLER-CASE.4 HANDLER-CASE.5 HANDLER-CASE.6

 HANDLER-CASE.7 HANDLER-CASE.9 HANDLER-CASE.11 HANDLER-CASE.12

 HANDLER-CASE.13 HANDLER-CASE.14 HANDLER-CASE.15 HANDLER-CASE.16

 HANDLER-CASE.17 HANDLER-CASE.18 HANDLER-CASE.19 HANDLER-CASE.20

 HANDLER-CASE.21 HANDLER-CASE.22 HANDLER-CASE.23 HANDLER-CASE.24

 HANDLER-CASE.25 HANDLER-CASE.26 HANDLER-CASE.27 HANDLER-CASE.28

 HANDLER-CASE.29 IGNORE-ERRORS.1 IGNORE-ERRORS.2 IGNORE-ERRORS.3

 IGNORE-ERRORS.4 IGNORE-ERRORS.5 IGNORE-ERRORS.6

 CONDITION-1/IS-SUBTYPE-OF/CONDITION

 CONDITION-1/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-1/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-1/IS-A/CONDITION

 CONDITION-1/IS-SUBCLASS-OF/CONDITION

 CONDITION-1/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-1/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-1/HANDLER-CASE-1

 CONDITION-1/HANDLER-CASE-2 CONDITION-1/HANDLER-CASE-3

 CONDITION-2/IS-SUBTYPE-OF/CONDITION

 CONDITION-2/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-2/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-2/IS-A/CONDITION

 CONDITION-2/IS-SUBCLASS-OF/CONDITION

 CONDITION-2/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-2/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-2/HANDLER-CASE-1

 CONDITION-2/HANDLER-CASE-2 CONDITION-2/HANDLER-CASE-3

 CONDITION-3/IS-SUBTYPE-OF/CONDITION

 CONDITION-3/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-3/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-3/IS-A/CONDITION

 CONDITION-3/IS-SUBCLASS-OF/CONDITION

 CONDITION-3/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-3/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-3/HANDLER-CASE-1

 CONDITION-3/HANDLER-CASE-2 CONDITION-3/HANDLER-CASE-3

 CONDITION-4/IS-SUBTYPE-OF/CONDITION

 CONDITION-4/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-4/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-4/IS-A/CONDITION

 CONDITION-4/IS-SUBCLASS-OF/CONDITION

 CONDITION-4/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-4/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-4/HANDLER-CASE-1

 CONDITION-4/HANDLER-CASE-2 CONDITION-4/HANDLER-CASE-3

 CONDITION-4-SLOTS.1 CONDITION-5/IS-SUBTYPE-OF/CONDITION

 CONDITION-5/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-5/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-5/IS-A/CONDITION

 CONDITION-5/IS-SUBCLASS-OF/CONDITION

 CONDITION-5/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-5/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-5/HANDLER-CASE-1

 CONDITION-5/HANDLER-CASE-2 CONDITION-5/HANDLER-CASE-3

 CONDITION-5-SLOTS.1 CONDITION-5-SLOTS.2 CONDITION-5-SLOTS.3

 CONDITION-5-SLOTS.4 CONDITION-6/IS-SUBTYPE-OF/CONDITION

 CONDITION-6/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-6/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-6/IS-A/CONDITION

 CONDITION-6/IS-SUBCLASS-OF/CONDITION

 CONDITION-6/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-6/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-6/HANDLER-CASE-1

 CONDITION-6/HANDLER-CASE-2 CONDITION-6/HANDLER-CASE-3

 CONDITION-6-SLOTS.1 CONDITION-6-SLOTS.2 CONDITION-6-SLOTS.3

 CONDITION-6-SLOTS.4 CONDITION-6-SLOTS.5

 CONDITION-7/IS-SUBTYPE-OF/CONDITION

 CONDITION-7/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-7/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-7/IS-A/CONDITION

 CONDITION-7/IS-SUBCLASS-OF/CONDITION

 CONDITION-7/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-7/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-7/HANDLER-CASE-1

 CONDITION-7/HANDLER-CASE-2 CONDITION-7/HANDLER-CASE-3

 CONDITION-7-SLOTS.1 CONDITION-7-SLOTS.2 CONDITION-7-SLOTS.3

 CONDITION-7-SLOTS.4 CONDITION-8/IS-SUBTYPE-OF/CONDITION

 CONDITION-8/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-8/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-8/IS-A/CONDITION

 CONDITION-8/IS-SUBCLASS-OF/CONDITION

 CONDITION-8/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-8/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-8/HANDLER-CASE-1

 CONDITION-8/HANDLER-CASE-2 CONDITION-8/HANDLER-CASE-3

 CONDITION-8-SLOTS.1 CONDITION-9/IS-SUBTYPE-OF/CONDITION

 CONDITION-9/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-9/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-9/IS-A/CONDITION

 CONDITION-9/IS-SUBCLASS-OF/CONDITION

 CONDITION-9/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-9/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-9/HANDLER-CASE-1

 CONDITION-9/HANDLER-CASE-2 CONDITION-9/HANDLER-CASE-3

 CONDITION-9-SLOTS.1 CONDITION-9-SLOTS.2 CONDITION-9-SLOTS.3

 CONDITION-9-SLOTS.4 CONDITION-9-SLOTS.5 CONDITION-9-SLOTS.6

 CONDITION-14/IS-SUBTYPE-OF/CONDITION

 CONDITION-14/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-14/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-14/IS-A/CONDITION

 CONDITION-14/IS-SUBCLASS-OF/CONDITION

 CONDITION-14/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-14/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-14/HANDLER-CASE-1

 CONDITION-14/HANDLER-CASE-2 CONDITION-14/HANDLER-CASE-3

 CONDITION-14-SLOTS.1 CONDITION-14-SLOTS.2 CONDITION-14-SLOTS.3

 CONDITION-15/IS-SUBTYPE-OF/CONDITION

 CONDITION-15/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-15/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-15/IS-A/CONDITION

 CONDITION-15/IS-SUBCLASS-OF/CONDITION

 CONDITION-15/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-15/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-15/HANDLER-CASE-1

 CONDITION-15/HANDLER-CASE-2 CONDITION-15/HANDLER-CASE-3

 CONDITION-16/IS-SUBTYPE-OF/CONDITION

 CONDITION-16/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-16/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-16/IS-A/CONDITION

 CONDITION-16/IS-SUBCLASS-OF/CONDITION

 CONDITION-16/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-16/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-16/HANDLER-CASE-1

 CONDITION-16/HANDLER-CASE-2 CONDITION-16/HANDLER-CASE-3

 CONDITION-16-REPORT.1 CONDITION-17/IS-SUBTYPE-OF/CONDITION

 CONDITION-17/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-17/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-17/IS-A/CONDITION

 CONDITION-17/IS-SUBCLASS-OF/CONDITION

 CONDITION-17/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-17/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-17/HANDLER-CASE-1

 CONDITION-17/HANDLER-CASE-2 CONDITION-17/HANDLER-CASE-3

 CONDITION-17-REPORT.1 CONDITION-18/IS-SUBTYPE-OF/CONDITION

 CONDITION-18/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-18/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-18/IS-A/CONDITION

 CONDITION-18/IS-SUBCLASS-OF/CONDITION

 CONDITION-18/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-18/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-18/HANDLER-CASE-1

 CONDITION-18/HANDLER-CASE-2 CONDITION-18/HANDLER-CASE-3

 CONDITION-18-REPORT.1 CONDITION-19/IS-SUBTYPE-OF/CONDITION

 CONDITION-19/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-19/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-19/IS-A/CONDITION

 CONDITION-19/IS-SUBCLASS-OF/CONDITION

 CONDITION-19/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-19/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-19/HANDLER-CASE-1

 CONDITION-19/HANDLER-CASE-2 CONDITION-19/HANDLER-CASE-3

 CONDITION-19-SLOTS.1 CONDITION-19-SLOTS.2 CONDITION-19-SLOTS.3

 CONDITION-19-SLOTS.4 CONDITION-19-SLOTS.5

 CONDITION-20/IS-SUBTYPE-OF/CONDITION

 CONDITION-20/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-20/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-20/IS-A/CONDITION

 CONDITION-20/IS-SUBCLASS-OF/CONDITION

 CONDITION-20/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-20/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-20/HANDLER-CASE-1

 CONDITION-20/HANDLER-CASE-2 CONDITION-20/HANDLER-CASE-3

 CONDITION-20-SLOTS.1 CONDITION-20-SLOTS.2 CONDITION-20-SLOTS.3

 CONDITION-20-SLOTS.4 CONDITION-21/IS-SUBTYPE-OF/CONDITION

 CONDITION-21/IS-SUBTYPE-OF/CONDITION-4

 CONDITION-21/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-21/IS-SUBTYPE-OF-2/CONDITION-4

 CONDITION-21/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-21/IS-NOT-SUPERTYPE-OF/CONDITION-4

 CONDITION-21/IS-A/CONDITION CONDITION-21/IS-A/CONDITION-4

 CONDITION-21/IS-SUBCLASS-OF/CONDITION

 CONDITION-21/IS-SUBCLASS-OF/CONDITION-4

 CONDITION-21/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-21/IS-NOT-SUPERCLASS-OF/CONDITION-4

 CONDITION-21/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-21/IS-A-MEMBER-OF-CLASS/CONDITION-4

 CONDITION-21/HANDLER-CASE-1 CONDITION-21/HANDLER-CASE-2

 CONDITION-21/HANDLER-CASE-3 CONDITION-21-SLOTS.1

 CONDITION-22/IS-SUBTYPE-OF/CONDITION

 CONDITION-22/IS-SUBTYPE-OF/CONDITION-4

 CONDITION-22/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-22/IS-SUBTYPE-OF-2/CONDITION-4

 CONDITION-22/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-22/IS-NOT-SUPERTYPE-OF/CONDITION-4

 CONDITION-22/IS-A/CONDITION CONDITION-22/IS-A/CONDITION-4

 CONDITION-22/IS-SUBCLASS-OF/CONDITION

 CONDITION-22/IS-SUBCLASS-OF/CONDITION-4

 CONDITION-22/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-22/IS-NOT-SUPERCLASS-OF/CONDITION-4

 CONDITION-22/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-22/IS-A-MEMBER-OF-CLASS/CONDITION-4

 CONDITION-22/HANDLER-CASE-1 CONDITION-22/HANDLER-CASE-2

 CONDITION-22/HANDLER-CASE-3 CONDITION-22-SLOTS.1

 CONDITION-23/IS-SUBTYPE-OF/CONDITION

 CONDITION-23/IS-SUBTYPE-OF/CONDITION-5

 CONDITION-23/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-23/IS-SUBTYPE-OF-2/CONDITION-5

 CONDITION-23/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-23/IS-NOT-SUPERTYPE-OF/CONDITION-5

 CONDITION-23/IS-A/CONDITION CONDITION-23/IS-A/CONDITION-5

 CONDITION-23/IS-SUBCLASS-OF/CONDITION

 CONDITION-23/IS-SUBCLASS-OF/CONDITION-5

 CONDITION-23/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-23/IS-NOT-SUPERCLASS-OF/CONDITION-5

 CONDITION-23/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-23/IS-A-MEMBER-OF-CLASS/CONDITION-5

 CONDITION-23/HANDLER-CASE-1 CONDITION-23/HANDLER-CASE-2

 CONDITION-23/HANDLER-CASE-3 CONDITION-23-SLOTS.1 CONDITION-23-SLOTS.2

 CONDITION-23-SLOTS.3 CONDITION-23-SLOTS.4

 CONDITION-24/IS-SUBTYPE-OF/CONDITION

 CONDITION-24/IS-SUBTYPE-OF/CONDITION-5

 CONDITION-24/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-24/IS-SUBTYPE-OF-2/CONDITION-5

 CONDITION-24/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-24/IS-NOT-SUPERTYPE-OF/CONDITION-5

 CONDITION-24/IS-A/CONDITION CONDITION-24/IS-A/CONDITION-5

 CONDITION-24/IS-SUBCLASS-OF/CONDITION

 CONDITION-24/IS-SUBCLASS-OF/CONDITION-5

 CONDITION-24/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-24/IS-NOT-SUPERCLASS-OF/CONDITION-5

 CONDITION-24/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-24/IS-A-MEMBER-OF-CLASS/CONDITION-5

 CONDITION-24/HANDLER-CASE-1 CONDITION-24/HANDLER-CASE-2

 CONDITION-24/HANDLER-CASE-3 CONDITION-24-SLOTS.1 CONDITION-24-SLOTS.2

 CONDITION-24-SLOTS.3 CONDITION-24-SLOTS.4

 CONDITION-25A/IS-SUBTYPE-OF/CONDITION

 CONDITION-25A/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-25A/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-25A/IS-A/CONDITION CONDITION-25A/IS-SUBCLASS-OF/CONDITION

 CONDITION-25A/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-25A/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-25A/HANDLER-CASE-1 CONDITION-25A/HANDLER-CASE-2

 CONDITION-25A/HANDLER-CASE-3 CONDITION-25B/IS-SUBTYPE-OF/CONDITION

 CONDITION-25B/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-25B/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-25B/IS-A/CONDITION CONDITION-25B/IS-SUBCLASS-OF/CONDITION

 CONDITION-25B/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-25B/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-25B/HANDLER-CASE-1 CONDITION-25B/HANDLER-CASE-2

 CONDITION-25B/HANDLER-CASE-3 CONDITION-25/IS-SUBTYPE-OF/CONDITION

 CONDITION-25/IS-SUBTYPE-OF/CONDITION-25A

 CONDITION-25/IS-SUBTYPE-OF/CONDITION-25B

 CONDITION-25/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-25/IS-SUBTYPE-OF-2/CONDITION-25A

 CONDITION-25/IS-SUBTYPE-OF-2/CONDITION-25B

 CONDITION-25/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-25/IS-NOT-SUPERTYPE-OF/CONDITION-25A

 CONDITION-25/IS-NOT-SUPERTYPE-OF/CONDITION-25B

 CONDITION-25/IS-A/CONDITION CONDITION-25/IS-A/CONDITION-25A

 CONDITION-25/IS-A/CONDITION-25B CONDITION-25/IS-SUBCLASS-OF/CONDITION

 CONDITION-25/IS-SUBCLASS-OF/CONDITION-25A

 CONDITION-25/IS-SUBCLASS-OF/CONDITION-25B

 CONDITION-25/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-25/IS-NOT-SUPERCLASS-OF/CONDITION-25A

 CONDITION-25/IS-NOT-SUPERCLASS-OF/CONDITION-25B

 CONDITION-25/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-25/IS-A-MEMBER-OF-CLASS/CONDITION-25A

 CONDITION-25/IS-A-MEMBER-OF-CLASS/CONDITION-25B

 CONDITION-25/HANDLER-CASE-1 CONDITION-25/HANDLER-CASE-2

 CONDITION-25/HANDLER-CASE-3 CONDITION-25-SLOTS.1 CONDITION-25-SLOTS.2

 CONDITION-25-SLOTS.3 CONDITION-25-SLOTS.4 CONDITION-25-SLOTS.5

 CONDITION-26A/IS-SUBTYPE-OF/CONDITION

 CONDITION-26A/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-26A/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-26A/IS-A/CONDITION CONDITION-26A/IS-SUBCLASS-OF/CONDITION

 CONDITION-26A/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-26A/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-26A/HANDLER-CASE-1 CONDITION-26A/HANDLER-CASE-2

 CONDITION-26A/HANDLER-CASE-3 CONDITION-26B/IS-SUBTYPE-OF/CONDITION

 CONDITION-26B/IS-SUBTYPE-OF/CONDITION-26A

 CONDITION-26B/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-26B/IS-SUBTYPE-OF-2/CONDITION-26A

 CONDITION-26B/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-26B/IS-NOT-SUPERTYPE-OF/CONDITION-26A

 CONDITION-26B/IS-A/CONDITION CONDITION-26B/IS-A/CONDITION-26A

 CONDITION-26B/IS-SUBCLASS-OF/CONDITION

 CONDITION-26B/IS-SUBCLASS-OF/CONDITION-26A

 CONDITION-26B/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-26B/IS-NOT-SUPERCLASS-OF/CONDITION-26A

 CONDITION-26B/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-26B/IS-A-MEMBER-OF-CLASS/CONDITION-26A

 CONDITION-26B/HANDLER-CASE-1 CONDITION-26B/HANDLER-CASE-2

 CONDITION-26B/HANDLER-CASE-3 CONDITION-26C/IS-SUBTYPE-OF/CONDITION

 CONDITION-26C/IS-SUBTYPE-OF/CONDITION-26A

 CONDITION-26C/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-26C/IS-SUBTYPE-OF-2/CONDITION-26A

 CONDITION-26C/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-26C/IS-NOT-SUPERTYPE-OF/CONDITION-26A

 CONDITION-26C/IS-A/CONDITION CONDITION-26C/IS-A/CONDITION-26A

 CONDITION-26C/IS-SUBCLASS-OF/CONDITION

 CONDITION-26C/IS-SUBCLASS-OF/CONDITION-26A

 CONDITION-26C/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-26C/IS-NOT-SUPERCLASS-OF/CONDITION-26A

 CONDITION-26C/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-26C/IS-A-MEMBER-OF-CLASS/CONDITION-26A

 CONDITION-26C/HANDLER-CASE-1 CONDITION-26C/HANDLER-CASE-2

 CONDITION-26C/HANDLER-CASE-3 CONDITION-26/IS-SUBTYPE-OF/CONDITION

 CONDITION-26/IS-SUBTYPE-OF/CONDITION-26B

 CONDITION-26/IS-SUBTYPE-OF/CONDITION-26C

 CONDITION-26/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-26/IS-SUBTYPE-OF-2/CONDITION-26B

 CONDITION-26/IS-SUBTYPE-OF-2/CONDITION-26C

 CONDITION-26/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-26/IS-NOT-SUPERTYPE-OF/CONDITION-26B

 CONDITION-26/IS-NOT-SUPERTYPE-OF/CONDITION-26C

 CONDITION-26/IS-A/CONDITION CONDITION-26/IS-A/CONDITION-26B

 CONDITION-26/IS-A/CONDITION-26C CONDITION-26/IS-SUBCLASS-OF/CONDITION

 CONDITION-26/IS-SUBCLASS-OF/CONDITION-26B

 CONDITION-26/IS-SUBCLASS-OF/CONDITION-26C

 CONDITION-26/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-26/IS-NOT-SUPERCLASS-OF/CONDITION-26B

 CONDITION-26/IS-NOT-SUPERCLASS-OF/CONDITION-26C

 CONDITION-26/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-26/IS-A-MEMBER-OF-CLASS/CONDITION-26B

 CONDITION-26/IS-A-MEMBER-OF-CLASS/CONDITION-26C

 CONDITION-26/HANDLER-CASE-1 CONDITION-26/HANDLER-CASE-2

 CONDITION-26/HANDLER-CASE-3 CONDITION-26-SLOTS.1 CONDITION-26-SLOTS.2

 CONDITION-27A/IS-SUBTYPE-OF/CONDITION

 CONDITION-27A/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-27A/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-27A/IS-A/CONDITION CONDITION-27A/IS-SUBCLASS-OF/CONDITION

 CONDITION-27A/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-27A/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-27A/HANDLER-CASE-1 CONDITION-27A/HANDLER-CASE-2

 CONDITION-27A/HANDLER-CASE-3 CONDITION-27B/IS-SUBTYPE-OF/CONDITION

 CONDITION-27B/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-27B/IS-NOT-SUPERTYPE-OF/CONDITION

 CONDITION-27B/IS-A/CONDITION CONDITION-27B/IS-SUBCLASS-OF/CONDITION

 CONDITION-27B/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-27B/IS-A-MEMBER-OF-CLASS/CONDITION

 CONDITION-27B/HANDLER-CASE-1 CONDITION-27B/HANDLER-CASE-2

 CONDITION-27B/HANDLER-CASE-3 CONDITION-27-SLOTS.1 CONDITION-27-SLOTS.2

 CONDITION-27-READER-IS-GENERIC CONDITION-30/IS-SUBTYPE-OF/CONDITION

 CONDITION-30/IS-SUBTYPE-OF-2/CONDITION

 CONDITION-30/IS-NOT-SUPERTYPE-OF/CONDITION CONDITION-30/IS-A/CONDITION

 CONDITION-30/IS-SUBCLASS-OF/CONDITION

 CONDITION-30/IS-NOT-SUPERCLASS-OF/CONDITION

 CONDITION-30/IS-A-MEMBER-OF-CLASS/CONDITION CONDITION-30/HANDLER-CASE-1

 CONDITION-30/HANDLER-CASE-2 CONDITION-30/HANDLER-CASE-3

 COMPUTE-RESTARTS.1 COMPUTE-RESTARTS.2 COMPUTE-RESTARTS.3

 COMPUTE-RESTARTS.4 COMPUTE-RESTARTS.5 COMPUTE-RESTARTS.6

 COMPUTE-RESTARTS.7 COMPUTE-RESTARTS.8 COMPUTE-RESTARTS.9 RESTART-BIND.1

 RESTART-BIND.2 RESTART-BIND.3 RESTART-BIND.4 RESTART-BIND.5

 RESTART-BIND.6 RESTART-BIND.7 RESTART-BIND.8 RESTART-BIND.9

 RESTART-BIND.10 RESTART-BIND.11 RESTART-BIND.12 RESTART-BIND.13

 RESTART-BIND.14 RESTART-BIND.15 RESTART-BIND.16 RESTART-BIND.17

 RESTART-BIND.18 RESTART-BIND.19 RESTART-BIND.21 RESTART-BIND.22

 RESTART-BIND.ERROR.1 RESTART-BIND.ERROR.2 RESTART-BIND.ERROR.3

 RESTART-BIND.23 RESTART-BIND.24 RESTART-CASE.1 RESTART-CASE.2

 RESTART-CASE.3 RESTART-CASE.4 RESTART-CASE.5 RESTART-CASE.6

 RESTART-CASE.7 RESTART-CASE.8 RESTART-CASE.9 RESTART-CASE.10

 RESTART-CASE.11 RESTART-CASE.12 RESTART-CASE.13 RESTART-CASE.14

 RESTART-CASE.15 RESTART-CASE.16 RESTART-CASE.17 RESTART-CASE.18

 RESTART-CASE.19 RESTART-CASE.20 RESTART-CASE.21 RESTART-CASE.22

 RESTART-CASE.23 RESTART-CASE.24 RESTART-CASE.25 RESTART-CASE.26

 RESTART-CASE.27 RESTART-CASE.28 RESTART-CASE.29 RESTART-CASE.30

 RESTART-CASE.31 RESTART-CASE.32 RESTART-CASE.33 RESTART-CASE.34

 RESTART-CASE.35 RESTART-CASE.36 WITH-CONDITION-RESTARTS.1

 WITH-CONDITION-RESTARTS.2 WITH-CONDITION-RESTARTS.3

 WITH-CONDITION-RESTARTS.4 WITH-CONDITION-RESTARTS.5

 WITH-CONDITION-RESTARTS.6 WITH-CONDITION-RESTARTS.7

 WITH-CONDITION-RESTARTS.8 WITH-SIMPLE-RESTART.1 WITH-SIMPLE-RESTART.2

 WITH-SIMPLE-RESTART.3 WITH-SIMPLE-RESTART.4 WITH-SIMPLE-RESTART.5

 WITH-SIMPLE-RESTART.6 WITH-SIMPLE-RESTART.7 WITH-SIMPLE-RESTART.8

 ABORT.1 ABORT.2 ABORT.3 ABORT.4 ABORT.5 MUFFLE-WARNING.1

 MUFFLE-WARNING.2 MUFFLE-WARNING.3 MUFFLE-WARNING.4 MUFFLE-WARNING.5

 CONTINUE.1 CONTINUE.2 CONTINUE.3 CONTINUE.4 CONTINUE.5 STORE-VALUE.1

 STORE-VALUE.2 STORE-VALUE.3 STORE-VALUE.4 STORE-VALUE.5 USE-VALUE.1

 USE-VALUE.2 USE-VALUE.3 USE-VALUE.4 USE-VALUE.5 MAKE-CONDITION.1

 MAKE-CONDITION.2 MAKE-CONDITION.3

Test MAKE-CONDITION.4 failed

Form: (LET* ((TP '(AND SIMPLE-ERROR TYPE-ERROR)) (C (MAKE-CONDITION TP)))

        (OR

         (NOT

          (AND (SUBTYPEP 'SIMPLE-ERROR TP)

               (SUBTYPEP 'TYPE-ERROR TP)

               (SUBTYPEP TP 'CONDITION)))

         (NOTNOT-MV (TYPEP C TP))))

Expected value: T

Actual value: #<a SIMPLE-TYPE-ERROR>.

 MAKE-CONDITION.ERROR.1 CONS-OF-SYMBOLS CONS-WITH-NIL CONS-EQ-EQUAL

 CONS-EQUAL-LIST CONS.ORDER.1 CONS.FOLD.1 CONS.ERROR.1 CONS.ERROR.2

 CONS.ERROR.3 CONSP-LIST CONSP-CONS CONSP-NIL CONSP-EMPTY-LIST

 CONSP-SINGLE-ELEMENT-LIST CONSP-XOR-ATOM-UNIVERSE CONSP-CONS-UNIVERSE

 CONSP.ORDER.1 CONSP.ERROR.1 CONSP.ERROR.2 ATOM.1 ATOM.2 ATOM.ORDER.1

 ATOM.ERROR.1 ATOM.ERROR.2 CONS.23 CONS.24 CONS.25 CONS.26 CONS.27

 CONS.28 CONS.29 CONS.30 CONS.31 CONS.32 CONS.33 CONS.34 CONS.36 CONS.37

 CONS.38 CONS.39 CONS.40 CONS.41 CONS.42 CONS.43 CONS.44 CONS.45 CONS.46

 CONS.47 CONS.48 CONS.49 CONS.50 CONS.51 CONS.52 CONS.53 CAR.1 CAR-NIL

 CAR.ERROR.1 CAR.ERROR.2 CAR.ORDER.1 CDR.1 CDR-NIL CDR.ORDER.1

 CDR.ERROR.1 CDR.ERROR.2 CAAR.ERROR.1 CAAR.ERROR.2 CADR.ERROR.1

 CADR.ERROR.2 CDAR.ERROR.1 CDAR.ERROR.2 CDDR.ERROR.1 CDDR.ERROR.2

 CAAAR.ERROR.1 CAAAR.ERROR.2 CAAAR.ERROR.3 CAADR.ERROR.1 CAADR.ERROR.2

 CAADR.ERROR.3 CADAR.ERROR.1 CADAR.ERROR.2 CADAR.ERROR.3 CADDR.ERROR.1

 CADDR.ERROR.2 CADDR.ERROR.3 CDAAR.ERROR.1 CDAAR.ERROR.2 CDAAR.ERROR.3

 CDADR.ERROR.1 CDADR.ERROR.2 CDADR.ERROR.3 CDDAR.ERROR.1 CDDAR.ERROR.2

 CDDAR.ERROR.3 CDDDR.ERROR.1 CDDDR.ERROR.2 CDDDR.ERROR.3 CAAAAR.ERROR.1

 CAAAAR.ERROR.2 CAAAAR.ERROR.3 CAAAAR.ERROR.4 CAAADR.ERROR.1

 CAAADR.ERROR.2 CAAADR.ERROR.3 CAAADR.ERROR.4 CAADAR.ERROR.1

 CAADAR.ERROR.2 CAADAR.ERROR.3 CAADAR.ERROR.4 CAADDR.ERROR.1

 CAADDR.ERROR.2 CAADDR.ERROR.3 CAADDR.ERROR.4 CADAAR.ERROR.1

 CADAAR.ERROR.2 CADAAR.ERROR.3 CADAAR.ERROR.4 CADADR.ERROR.1

 CADADR.ERROR.2 CADADR.ERROR.3 CADADR.ERROR.4 CADDAR.ERROR.1

 CADDAR.ERROR.2 CADDAR.ERROR.3 CADDAR.ERROR.4 CADDDR.ERROR.1

 CADDDR.ERROR.2 CADDDR.ERROR.3 CADDDR.ERROR.4 CDAAAR.ERROR.1

 CDAAAR.ERROR.2 CDAAAR.ERROR.3 CDAAAR.ERROR.4 CDAADR.ERROR.1

 CDAADR.ERROR.2 CDAADR.ERROR.3 CDAADR.ERROR.4 CDADAR.ERROR.1

 CDADAR.ERROR.2 CDADAR.ERROR.3 CDADAR.ERROR.4 CDADDR.ERROR.1

 CDADDR.ERROR.2 CDADDR.ERROR.3 CDADDR.ERROR.4 CDDAAR.ERROR.1

 CDDAAR.ERROR.2 CDDAAR.ERROR.3 CDDAAR.ERROR.4 CDDADR.ERROR.1

 CDDADR.ERROR.2 CDDADR.ERROR.3 CDDADR.ERROR.4 CDDDAR.ERROR.1

 CDDDAR.ERROR.2 CDDDAR.ERROR.3 CDDDAR.ERROR.4 CDDDDR.ERROR.1

 CDDDDR.ERROR.2 CDDDDR.ERROR.3 CDDDDR.ERROR.4 CAR-SET-ALT CDR-SET-ALT

 CAAR-SET-ALT CADR-SET-ALT CDAR-SET-ALT CDDR-SET-ALT CAAAR-SET-ALT

 CAADR-SET-ALT CADAR-SET-ALT CADDR-SET-ALT CDAAR-SET-ALT CDADR-SET-ALT

 CDDAR-SET-ALT CDDDR-SET-ALT CAAAAR-SET-ALT CAAADR-SET-ALT

 CAADAR-SET-ALT CAADDR-SET-ALT CADAAR-SET-ALT CADADR-SET-ALT

 CADDAR-SET-ALT CADDDR-SET-ALT CDAAAR-SET-ALT CDAADR-SET-ALT

 CDADAR-SET-ALT CDADDR-SET-ALT CDDAAR-SET-ALT CDDADR-SET-ALT

 CDDDAR-SET-ALT CDDDDR-SET-ALT FIRST-SET-ALT SECOND-SET-ALT

 THIRD-SET-ALT FOURTH-SET-ALT FIFTH-SET-ALT SIXTH-SET-ALT

 SEVENTH-SET-ALT EIGHTH-SET-ALT NINTH-SET-ALT TENTH-SET-ALT RPLACA.1

 RPLACA.ORDER.1 RPLACA.ERROR.1 RPLACA.ERROR.2 RPLACA.ERROR.3

 RPLACA.ERROR.4 RPLACA.ERROR.6 RPLACD.1 RPLACD.ORDER.1 RPLACD.ERROR.1

 RPLACD.ERROR.2 RPLACD.ERROR.3 RPLACD.ERROR.4 RPLACD.ERROR.6 COPY-TREE.1

 COPY-TREE.2 COPY-TREE.ORDER.1 COPY-TREE.FOLD.1 COPY-TREE.FOLD.2

 COPY-TREE.FOLD.3 COPY-TREE.ERROR.1 COPY-TREE.ERROR.2 SUBLIS.1 SUBLIS.2

 SUBLIS.3 SUBLIS.4 SUBLIS.5 SUBLIS.6 SUBLIS.7 SUBLIS.8 SUBLIS.9

 SUBLIS.10 SUBLIS.TEST-AND-TEST-NOT.1 SUBLIS.TEST-AND-TEST-NOT.2

 SUBLIS.ORDER.1 SUBLIS.ORDER.2 SUBLIS.FOLD.1 SUBLIS.ALLOW-OTHER-KEYS.1

 SUBLIS.ALLOW-OTHER-KEYS.2 SUBLIS.ALLOW-OTHER-KEYS.3

 SUBLIS.ALLOW-OTHER-KEYS.4 SUBLIS.ALLOW-OTHER-KEYS.5 SUBLIS.KEYWORDS.6

 SUBLIS.ERROR.1 SUBLIS.ERROR.2 SUBLIS.ERROR.3 SUBLIS.ERROR.4

 SUBLIS.ERROR.5 SUBLIS.ERROR.6 SUBLIS.ERROR.7 SUBLIS.ERROR.8

 SUBLIS.SHARED NSUBLIS.1 NSUBLIS.2 NSUBLIS.3 NSUBLIS.4 NSUBLIS.5

 NSUBLIS.6 NSUBLIS.7 NSUBLIS.8 NSUBLIS.9 NSUBLIS.10 NSUBLIS.11

 NSUBLIS.TEST-AND-TEST-NOT.1 NSUBLIS.TEST-AND-TEST-NOT.2 NSUBLIS.ORDER.1

 NSUBLIS.ORDER.2 NSUBLIS.ALLOW-OTHER-KEYS.1 NSUBLIS.ALLOW-OTHER-KEYS.2

 NSUBLIS.ALLOW-OTHER-KEYS.3 NSUBLIS.ALLOW-OTHER-KEYS.4

 NSUBLIS.ALLOW-OTHER-KEYS.5 NSUBLIS.KEYWORDS.6 NSUBLIS.ERROR.1

 NSUBLIS.ERROR.2 NSUBLIS.ERROR.3 NSUBLIS.ERROR.4 NSUBLIS.ERROR.5

 NSUBLIS.ERROR.6 NSUBLIS.ERROR.7 NSUBLIS.ERROR.8 SUBST.1 SUBST.2 SUBST.3

 SUBST.4 SUBST.5 SUBST.6 SUBST.7 SUBST.8 SUBST.9 SUBST.10 SUBST.11

 SUBSET.TEST-AND-TEST-NOT.1 SUBSET.TEST-AND-TEST-NOT.2 SUBST.ORDER.1

 SUBST.ORDER.2 SUBST.FOLD.1 SUBST.ALLOW-OTHER-KEYS.1

 SUBST.ALLOW-OTHER-KEYS.2 SUBST.ALLOW-OTHER-KEYS.3

 SUBST.ALLOW-OTHER-KEYS.4 SUBST.ALLOW-OTHER-KEYS.5 SUBST.KEYWORDS.6

 SUBST.ERROR.1 SUBST.ERROR.2 SUBST.ERROR.3 SUBST.ERROR.4 SUBST.ERROR.5

 SUBST.ERROR.6 SUBST.ERROR.7 SUBST.ERROR.8 SUBST.ERROR.9 SUBST.ERROR.10

 SUBST-IF.1 SUBST-IF.2 SUBST-IF.3 SUBST-IF.4 SUBST-IF.5 SUBST-IF.6

 SUBST-IF.7 SUBST-IF.FOLD.1 SUBST-IF.ALLOW-OTHER-KEYS.1

 SUBST-IF.ALLOW-OTHER-KEYS.2 SUBST-IF.ALLOW-OTHER-KEYS.3

 SUBST-IF.ALLOW-OTHER-KEYS.4 SUBST-IF.ALLOW-OTHER-KEYS.5

 SUBST-IF.KEYWORDS.6 SUBST-IF.ERROR.1 SUBST-IF.ERROR.2 SUBST-IF.ERROR.3

 SUBST-IF.ERROR.4 SUBST-IF.ERROR.5 SUBST-IF.ERROR.6 SUBST-IF.ERROR.7

 SUBST-IF.ERROR.8 SUBST-IF-NOT.1 SUBST-IF-NOT.2 SUBST-IF-NOT.3

 SUBST-IF-NOT.4 SUBST-IF-NOT.5 SUBST-IF-NOT.7 SUBST-IF-NOT.FOLD.1

 SUBST-IF-NOT.ALLOW-OTHER-KEYS.1 SUBST-IF-NOT.ALLOW-OTHER-KEYS.2

 SUBST-IF-NOT.ALLOW-OTHER-KEYS.3 SUBST-IF-NOT.ALLOW-OTHER-KEYS.4

 SUBST-IF-NOT.ALLOW-OTHER-KEYS.5 SUBST-IF-NOT.KEYWORDS.6

 SUBST-IF-NOT.ERROR.1 SUBST-IF-NOT.ERROR.2 SUBST-IF-NOT.ERROR.3

 SUBST-IF-NOT.ERROR.4 SUBST-IF-NOT.ERROR.5 SUBST-IF-NOT.ERROR.6

 SUBST-IF-NOT.ERROR.7 SUBST-IF-NOT.ERROR.8 NSUBST.1 NSUBST.2 NSUBST.3

 NSUBST.4 NSUBST.5 NSUBST.6 NSUBST.7 NSUBST.8 NSUBST.9 NSUBST.10

 NSUBST.11 NSUBSET.TEST-AND-TEST-NOT.1 NSUBSET.TEST-AND-TEST-NOT.2

 NSUBST.ORDER.1 NSUBST.ORDER.2 NSUBST.ALLOW-OTHER-KEYS.1

 NSUBST.ALLOW-OTHER-KEYS.2 NSUBST.ALLOW-OTHER-KEYS.3

 NSUBST.ALLOW-OTHER-KEYS.4 NSUBST.ALLOW-OTHER-KEYS.5 NSUBST.KEYWORDS.6

 NSUBST.ERROR.1 NSUBST.ERROR.2 NSUBST.ERROR.3 NSUBST.ERROR.4

 NSUBST.ERROR.5 NSUBST.ERROR.6 NSUBST.ERROR.7 NSUBST.ERROR.8

 NSUBST.ERROR.9 NSUBST.ERROR.10 NSUBST-IF.1 NSUBST-IF.2 NSUBST-IF.3

 NSUBST-IF.4 NSUBST-IF.5 NSUBST-IF.6 NSUBST-IF.7 NSUBST-IF.8

 NSUBST-IF.ALLOW-OTHER-KEYS.1 NSUBST-IF.ALLOW-OTHER-KEYS.2

 NSUBST-IF.ALLOW-OTHER-KEYS.3 NSUBST-IF.ALLOW-OTHER-KEYS.4

 NSUBST-IF.ALLOW-OTHER-KEYS.5 NSUBST-IF.KEYWORDS.6 NSUBST-IF.ERROR.1

 NSUBST-IF.ERROR.2 NSUBST-IF.ERROR.3 NSUBST-IF.ERROR.4 NSUBST-IF.ERROR.5

 NSUBST-IF.ERROR.6 NSUBST-IF.ERROR.7 NSUBST-IF.ERROR.8 NSUBST-IF-NOT.1

 NSUBST-IF-NOT.2 NSUBST-IF-NOT.3 NSUBST-IF-NOT.4 NSUBST-IF-NOT.5

 NSUBST-IF-NOT.6 NSUBST-IF-NOT.7 NSUBST-IF-NOT.ALLOW-OTHER-KEYS.1

 NSUBST-IF-NOT.ALLOW-OTHER-KEYS.2 NSUBST-IF-NOT.ALLOW-OTHER-KEYS.3

 NSUBST-IF-NOT.ALLOW-OTHER-KEYS.4 NSUBST-IF-NOT.ALLOW-OTHER-KEYS.5

 NSUBST-IF-NOT.KEYWORDS.6 NSUBST-IF-NOT.ERROR.1 NSUBST-IF-NOT.ERROR.2

 NSUBST-IF-NOT.ERROR.3 NSUBST-IF-NOT.ERROR.4 NSUBST-IF-NOT.ERROR.5

 NSUBST-IF-NOT.ERROR.6 NSUBST-IF-NOT.ERROR.7 NSUBST-IF-NOT.ERROR.8

 TREE-EQUAL.1 TREE-EQUAL.2 TREE-EQUAL.3 TREE-EQUAL.4 TREE-EQUAL.5

 TREE-EQUAL.6 TREE-EQUAL.7 TREE-EQUAL.8 TREE-EQUAL.9 TREE-EQUAL.10

 TREE-EQUAL.11 TREE-EQUAL.12 TREE-EQUAL.13 TREE-EQUAL.14 TREE-EQUAL.15

 TREE-EQUAL.16 TREE-EQUAL.TEST-AND-TEST-NOT.1

 TREE-EQUAL.TEST-AND-TEST-NOT.2 TREE-EQUAL.ALLOW-OTHER-KEYS.1

 TREE-EQUAL.ALLOW-OTHER-KEYS.2 TREE-EQUAL.ALLOW-OTHER-KEYS.3

 TREE-EQUAL.ALLOW-OTHER-KEYS.4 TREE-EQUAL.KEYWORDS.1 TREE-EQUAL.ERROR.1

 TREE-EQUAL.ERROR.2 TREE-EQUAL.ERROR.3 TREE-EQUAL.ERROR.4

 TREE-EQUAL.ERROR.5 TREE-EQUAL.ERROR.6 COPY-LIST.1 COPY-LIST.2

 COPY-LIST.3 COPY-LIST.4 COPY-LIST.FOLD.1 COPY-LIST.FOLD.2

 COPY-LIST.ERROR.1 COPY-LIST.ERROR.2 LIST.1 LIST.2 LIST.ORDER.1

 LIST.ORDER.2 LIST.ORDER.3 LIST.FOLD.1 LIST.FOLD.2 LIST.FOLD.3 LIST*.1

 LIST*.2 LIST-LIST*.1 LIST*.3 LIST*.ORDER.1 LIST*.ORDER.2 LIST*.FOLD.1

 LIST*.FOLD.2 LIST*.FOLD.3 LIST-LENGTH-NIL LIST-LENGTH-LIST

 LIST-LENGTH-CIRCULAR-LIST LIST-LENGTH.ORDER.1 LIST-LENGTH.4

 LIST-LENGTH.ERROR.1 LIST-LENGTH.ERROR.2 LIST-LENGTH.ERROR.3

 LIST-LENGTH.ERROR.4 LIST-LENGTH.ERROR.5 LIST-LENGTH-SYMBOL

 LIST-LENGTH-DOTTED-LIST LISTP-NIL LISTP-SYMBOL LISTP-SINGLETON-LIST

 LISTP-CIRCULAR-LIST LISTP-LONGER-LIST LISTP-UNIVERSE LISTP.ORDER.1

 LISTP.ERROR.1 LISTP.ERROR.2 MAKE-LIST-EMPTY.1 MAKE-LIST-EMPTY.2

 MAKE-LIST-NO-INITIAL-ELEMENT MAKE-LIST-WITH-INITIAL-ELEMENT

 MAKE-LIST.ALLOW-OTHER-KEYS.1 MAKE-LIST.ALLOW-OTHER-KEYS.2

 MAKE-LIST.ALLOW-OTHER-KEYS.3 MAKE-LIST.ALLOW-OTHER-KEYS.4

 MAKE-LIST.ALLOW-OTHER-KEYS.5 MAKE-LIST-REPEATED-KEYWORD

 MAKE-LIST.ORDER.1 MAKE-LIST.ORDER.2 MAKE-LIST.FOLD.1 MAKE-LIST.FOLD.2

 MAKE-LIST.ERROR.1 MAKE-LIST.ERROR.3 MAKE-LIST.ERROR.4 MAKE-LIST.ERROR.5

 MAKE-LIST.ERROR.6 MAKE-LIST.ERROR.7 MAKE-LIST.ERROR.8 PUSH.1 PUSH.2

 PUSH.3 PUSH.4 PUSH.5 PUSH.ORDER.1 PUSH.ORDER.2 PUSH.ORDER.3

 PUSH.ERROR.1 POP.1 POP.2 POP.3 POP.ORDER.1 PUSH-AND-POP POP.ERROR.1

 PUSHNEW.1 PUSHNEW.2 PUSHNEW.3 PUSHNEW.4 PUSHNEW.5 PUSHNEW.6 PUSHNEW.7

 PUSHNEW.8 PUSHNEW.9 PUSHNEW.10 PUSHNEW.11 PUSHNEW.12 PUSHNEW.13

 PUSHNEW.14 PUSHNEW.15 PUSHNEW.16 PUSHNEW.17 PUSHNEW.18 PUSHNEW.19

 PUSHNEW.20 PUSHNEW.21 PUSHNEW.22 PUSHNEW.23 PUSHNEW.24

 PUSHNEW.TEST-AND-TEST-NOT.1 PUSHNEW.TEST-AND-TEST-NOT.2 PUSHNEW.ORDER.1

 PUSHNEW.ORDER.2 PUSHNEW.ORDER.3 PUSHNEW.ERROR.1 PUSHNEW.ERROR.2

 PUSHNEW.ERROR.3 PUSHNEW.ERROR.4 ADJOIN.1 ADJOIN.2 ADJOIN.3 ADJOIN.4

 ADJOIN.5 ADJOIN.6 ADJOIN.7 ADJOIN.8 ADJOIN.9 ADJOIN.10 ADJOIN.11

 ADJOIN.12 ADJOIN.14 ADJOIN.15 ADJOIN.16 ADJOIN.17 ADJOIN.18 ADJOIN.19

 ADJOIN.20 ADJOIN.21 ADJOIN.22 ADJOIN.24 ADJOIN.TEST-AND-TEST-NOT.1

 ADJOIN.TEST-AND-TEST-NOT.2 ADJOIN.ORDER.1 ADJOIN.ORDER.2 ADJOIN.FOLD.1

 ADJOIN.ALLOW-OTHER-KEYS.1 ADJOIN.ALLOW-OTHER-KEYS.2

 ADJOIN.ALLOW-OTHER-KEYS.3 ADJOIN.ALLOW-OTHER-KEYS.4

 ADJOIN.ALLOW-OTHER-KEYS.5 ADJOIN.REPEAT-KEY ADJOIN.ERROR.1

 ADJOIN.ERROR.2 ADJOIN.ERROR.3 ADJOIN.ERROR.4 ADJOIN.ERROR.5

 ADJOIN.ERROR.6 ADJOIN.ERROR.7 ADJOIN.ERROR.8 ADJOIN.ERROR.9

 ADJOIN.ERROR.10 NTH.1 NTH.2 NTH.ORDER.1 NTH.ORDER.2 NTH.ERROR.1

 NTH.ERROR.2 NTH.ERROR.3 NTH.ERROR.4 ENDP-NIL ENDP-CONS

 ENDP-SINGLETON-LIST ENDP.ORDER.1 ENDP.ERROR.1 ENDP.ERROR.4 ENDP.ERROR.5

 ENDP.ERROR.6 NCONC.1 NCONC.2 NCONC.4 NCONC.5 NCONC.6 NCONC.7

 NCONC.ORDER.1 NCONC.ORDER.2 APPEND.1 APPEND.2 APPEND.3 APPEND.4

 APPEND.5 APPEND.6 APPEND.7 APPEND.8 APPEND.9 APPEND.10 APPEND.ORDER.1

 APPEND.ORDER.2 APPEND.FOLD.1 APPEND.FOLD.2 APPEND.ERROR.1

 APPEND.ERROR.2 REVAPPEND.1 REVAPPEND.2 REVAPPEND.3 REVAPPEND.4

 REVAPPEND.ORDER.1 REVAPPEND.FOLD.1 REVAPPEND.FOLD.2 REVAPPEND.ERROR.1

 REVAPPEND.ERROR.2 REVAPPEND.ERROR.3 REVAPPEND.ERROR.4 NRECONC.1

 NRECONC.2 NRECONC.ORDER.1 NRECONC.ERROR.1 NRECONC.ERROR.2

 NRECONC.ERROR.3 NRECONC.ERROR.4 BUTLAST.1 BUTLAST.2 BUTLAST.3 BUTLAST.4

 BUTLAST.5 BUTLAST.6 BUTLAST.7 BUTLAST.8 BUTLAST.9 BUTLAST.ORDER.1

 BUTLAST.ORDER.2 BUTLAST.FOLD.1 BUTLAST.FOLD.2 BUTLAST.FOLD.3

 BUTLAST.ERROR.1 BUTLAST.ERROR.2 BUTLAST.ERROR.3 BUTLAST.ERROR.4

 BUTLAST.ERROR.5 NBUTLAST.1 NBUTLAST.2 NBUTLAST.3 NBUTLAST.4 NBUTLAST.5

 NBUTLAST.6 NBUTLAST.7 NBUTLAST.8 NBUTLAST.9 NBUTLAST.ORDER.1

 NBUTLAST.ORDER.2 NBUTLAST.ERROR.1 NBUTLAST.ERROR.2 NBUTLAST.ERROR.3

 NBUTLAST.ERROR.4 NBUTLAST.ERROR.5 NBUTLAST.ERROR.6 NBUTLAST.ERROR.7

 NBUTLAST.ERROR.8 NBUTLAST.ERROR.9 NBUTLAST.ERROR.10 LAST.1 LAST.2

 LAST.3 LAST.4 LAST.5 LAST.6 LAST.7 LAST.8 LAST.9 LAST.10 LAST.11

 LAST.12 LAST.13 LAST.14 LAST.ORDER.1 LAST.ORDER.2 LAST.ERROR.1

 LAST.ERROR.2 LAST.ERROR.3 LAST.ERROR.4 LAST.ERROR.5 LAST.ERROR.6

 LAST.ERROR.7 LAST.ERROR.8 LDIFF.1 LDIFF.2 LDIFF.3 LDIFF.4 LDIFF.5

 LDIFF.6 LDIFF.7 LDIFF.8 LDIFF.ORDER.1 LDIFF.FOLD.1 LDIFF.FOLD.2

 LDIFF.ERROR.1 LDIFF.ERROR.2 LDIFF.ERROR.3 LDIFF.ERROR.4 LDIFF.ERROR.5

 LDIFF.ERROR.6 LDIFF.ERROR.7 LDIFF.ERROR.8 TAILP.1 TAILP.2 TAILP.3

 TAILP.4 TAILP.5 TAILP.ERROR.5 TAILP.ERROR.6 TAILP.ERROR.7 TAILP.6

 TAILP.ORDER.1 NTHCDR.ERROR.1 NTHCDR.ERROR.6 NTHCDR.ERROR.7

 NTHCDR.ERROR.8 NTHCDR.ERROR.9 NTHCDR.ERROR.10 NTHCDR.ERROR.11 NTHCDR.1

 NTHCDR.2 NTHCDR.3 NTHCDR.4 NTHCDR.5 NTHCDR.ORDER.1 REST.1 REST.ORDER.1

 REST.ERROR.1 REST.ERROR.2 MEMBER.1 MEMBER.2 MEMBER.3 MEMBER.4 MEMBER.5

 MEMBER.6 MEMBER.7 MEMBER.8 MEMBER.9 MEMBER.10 MEMBER.11 MEMBER.12

 MEMBER.13 MEMBER.14 MEMBER.15 MEMBER.16 MEMBER.16-A MEMBER.17 MEMBER.18

 MEMBER.19 MEMBER.20 MEMBER.21 MEMBER.TEST-AND-TEST-NOT.1

 MEMBER.TEST-AND-TEST-NOT.2 MEMBER.ORDER.1 MEMBER.ORDER.2 MEMBER.ORDER.3

 MEMBER.ORDER.4 MEMBER.ORDER.5 MEMBER.ALLOW-OTHER-KEYS.1

 MEMBER.ALLOW-OTHER-KEYS.2 MEMBER.ALLOW-OTHER-KEYS.3

 MEMBER.ALLOW-OTHER-KEYS.4 MEMBER.ALLOW-OTHER-KEYS.5 MEMBER.KEYWORDS.6

 MEMBER.ERROR.1 MEMBER.ERROR.2 MEMBER.ERROR.3 MEMBER.ERROR.4

 MEMBER.ERROR.5 MEMBER.ERROR.6 MEMBER.ERROR.7 MEMBER.ERROR.8

 MEMBER.ERROR.9 MEMBER.ERROR.10 MEMBER.ERROR.11 MEMBER.ERROR.12

 MEMBER.ERROR.13 MEMBER.ERROR.14 MEMBER.ERROR.15 MEMBER.ERROR.16

 MEMBER.ERROR.17 MEMBER-IF.1 MEMBER-IF.2 MEMBER-IF.3 MEMBER-IF.4

 MEMBER-IF.5 MEMBER-IF.ORDER.1 MEMBER-IF.ORDER.2 MEMBER-IF.KEYWORDS.1

 MEMBER-IF.ALLOW-OTHER-KEYS.2 MEMBER-IF.ALLOW-OTHER-KEYS.3

 MEMBER-IF.ALLOW-OTHER-KEYS.4 MEMBER-IF.ALLOW-OTHER-KEYS.5

 MEMBER-IF.ALLOW-OTHER-KEYS.6 MEMBER-IF.ALLOW-OTHER-KEYS.7

 MEMBER-IF.ERROR.1 MEMBER-IF.ERROR.2 MEMBER-IF.ERROR.3 MEMBER-IF.ERROR.4

 MEMBER-IF.ERROR.5 MEMBER-IF.ERROR.6 MEMBER-IF.ERROR.7 MEMBER-IF.ERROR.8

 MEMBER-IF.ERROR.9 MEMBER-IF.ERROR.10 MEMBER-IF-NOT.1 MEMBER-IF-NOT.2

 MEMBER-IF-NOT.3 MEMBER-IF-NOT.4 MEMBER-IF-NOT.5 MEMBER-IF-NOT.ORDER.1

 MEMBER-IF-NOT.ORDER.2 MEMBER-IF-NOT.KEYWORDS.1

 MEMBER-IF-NOT.ALLOW-OTHER-KEYS.2 MEMBER-IF-NOT.ALLOW-OTHER-KEYS.3

 MEMBER-IF-NOT.ALLOW-OTHER-KEYS.4 MEMBER-IF-NOT.ALLOW-OTHER-KEYS.5

 MEMBER-IF-NOT.ALLOW-OTHER-KEYS.6 MEMBER-IF-NOT.ERROR.1

 MEMBER-IF-NOT.ERROR.2 MEMBER-IF-NOT.ERROR.3 MEMBER-IF-NOT.ERROR.4

 MEMBER-IF-NOT.ERROR.5 MEMBER-IF-NOT.ERROR.6 MEMBER-IF-NOT.ERROR.7

 MEMBER-IF-NOT.ERROR.8 MEMBER-IF-NOT.ERROR.9 MEMBER-IF-NOT.ERROR.10

 MAPC.1 MAPC.2 MAPC.3 MAPC.4 MAPC.5 MAPC.6 MAPC.ORDER.1 MAPC.ERROR.1

 MAPC.ERROR.2 MAPC.ERROR.3 MAPC.ERROR.4 MAPC.ERROR.5 MAPC.ERROR.6

 MAPC.ERROR.7 MAPC.ERROR.8 MAPCAR.1 MAPCAR.2 MAPCAR.3 MAPCAR.4 MAPCAR.5

 MAPCAR.6 MAPCAR.ORDER.1 MAPCAR.FOLD.1 MAPCAR.FOLD.2 MAPCAR.ERROR.1

 MAPCAR.ERROR.2 MAPCAR.ERROR.3 MAPCAR.ERROR.4 MAPCAR.ERROR.5

 MAPCAR.ERROR.6 MAPCAR.ERROR.7 MAPCAR.ERROR.8 MAPCAN.1 MAPCAN.2 MAPCAN.3

 MAPCAN.4 MAPCAN.5 MAPCAN.6 MAPCAN.ORDER.1 MAPCAN.8 MAPCAN.9 MAPCAN.10

 MAPCAN.11 MAPCAN.ERROR.1 MAPCAN.ERROR.2 MAPCAN.ERROR.3 MAPCAN.ERROR.4

 MAPCAN.ERROR.5 MAPCAN.ERROR.6 MAPCAN.ERROR.7 MAPCAN.ERROR.8 MAPL.1

 MAPL.2 MAPL.3 MAPL.4 MAPL.5 MAPL.ORDER.1 MAPL.ERROR.1 MAPL.ERROR.2

 MAPL.ERROR.3 MAPL.ERROR.4 MAPL.ERROR.5 MAPL.ERROR.6 MAPL.ERROR.7

 MAPL.ERROR.8 MAPLIST.1 MAPLIST.2 MAPLIST.3 MAPLIST.4 MAPLIST.5

 MAPLIST.6 MAPLIST.7 MAPLIST.ORDER.1 MAPLIST.FOLD.1 MAPLIST.FOLD.2

 MAPLIST.ERROR.1 MAPLIST.ERROR.2 MAPLIST.ERROR.3 MAPLIST.ERROR.4

 MAPLIST.ERROR.5 MAPLIST.ERROR.6 MAPLIST.ERROR.7 MAPLIST.ERROR.8

 MAPLIST.ERROR.9 MAPLIST.ERROR.10 MAPLIST.ERROR.11 MAPCON.1 MAPCON.2

 MAPCON.3 MAPCON.4 MAPCON.ORDER.1 MAPCON.ERROR.1 MAPCON.ERROR.2

 MAPCON.ERROR.3 MAPCON.ERROR.4 MAPCON.ERROR.5 MAPCON.ERROR.6

 MAPCON.ERROR.7 MAPCON.ERROR.8 ACONS.1 ACONS.2 ACONS.3 ACONS.4 ACONS.5

 ACONS.6 ACONS.7 ACONS.8 ACONS.9 ACONS.ORDER.1 ACONS.FOLD.1 ACONS.FOLD.2

 ACONS.ERROR.1 ACONS.ERROR.2 ACONS.ERROR.3 ACONS.ERROR.4 ASSOC.1 ASSOC.2

 ASSOC.3 ASSOC.4 ASSOC.5 ASSOC.6 ASSOC.7 ASSOC.8 ASSOC.9 ASSOC.10

 ASSOC.11 ASSOC.12 ASSOC.13 ASSOC.14 ASSOC.15 ASSOC.16 ASSOC.17 ASSOC.18

 ASSOC.19 ASSOC.20 ASSOC.21 ASSOC.22 ASSOC.23 ASSOC.24 ASSOC.25 ASSOC.26

 ASSOC.27 ASSOC.30 ASSOC.31 ASSOC.TEST-AND-TEST-NOT.1

 ASSOC.TEST-AND-TEST-NOT.2 ASSOC.ORDER.1 ASSOC.ORDER.2 ASSOC.ORDER.3

 ASSOC.ORDER.4 ASSOC.ALLOW-OTHER-KEYS.1 ASSOC.ALLOW-OTHER-KEYS.2

 ASSOC.ALLOW-OTHER-KEYS.3 ASSOC.ALLOW-OTHER-KEYS.4

 ASSOC.ALLOW-OTHER-KEYS.5 ASSOC.KEYWORDS.6 ASSOC.KEYWORDS.7

 ASSOC.ERROR.1 ASSOC.ERROR.2 ASSOC.ERROR.3 ASSOC.ERROR.4 ASSOC.ERROR.5

 ASSOC.ERROR.6 ASSOC.ERROR.7 ASSOC.ERROR.8 ASSOC.ERROR.9 ASSOC.ERROR.10

 ASSOC.ERROR.11 ASSOC.ERROR.12 ASSOC-IF.1 ASSOC-IF.2 ASSOC-IF.3

 ASSOC-IF.4 ASSOC-IF.5 ASSOC-IF.ORDER.1 ASSOC-IF.ORDER.2

 ASSOC-IF.ALLOW-OTHER-KEYS.1 ASSOC-IF.ALLOW-OTHER-KEYS.2

 ASSOC-IF.ALLOW-OTHER-KEYS.3 ASSOC-IF.ALLOW-OTHER-KEYS.4

 ASSOC-IF.ALLOW-OTHER-KEYS.5 ASSOC-IF.KEYWORDS.6 ASSOC-IF.KEYWORDS.7

 ASSOC-IF.ENV.1 ASSOC-IF.ERROR.1 ASSOC-IF.ERROR.2 ASSOC-IF.ERROR.3

 ASSOC-IF.ERROR.4 ASSOC-IF.ERROR.5 ASSOC-IF.ERROR.6 ASSOC-IF.ERROR.7

 ASSOC-IF.ERROR.8 ASSOC-IF.ERROR.9 ASSOC-IF.ERROR.10 ASSOC-IF.ERROR.11

 ASSOC-IF.ERROR.12 ASSOC-IF.ERROR.13 ASSOC-IF-NOT.1 ASSOC-IF-NOT.2

 ASSOC-IF-NOT.3 ASSOC-IF-NOT.4 ASSOC-IF-NOT.ORDER.1 ASSOC-IF-NOT.ORDER.2

 ASSOC-IF-NOT.ALLOW-OTHER-KEYS.1 ASSOC-IF-NOT.ALLOW-OTHER-KEYS.2

 ASSOC-IF-NOT.ALLOW-OTHER-KEYS.3 ASSOC-IF-NOT.ALLOW-OTHER-KEYS.4

 ASSOC-IF-NOT.ALLOW-OTHER-KEYS.5 ASSOC-IF-NOT.KEYWORDS.6

 ASSOC-IF-NOT.KEYWORDS.7 ASSOC-IF-NOT.ENV.1 ASSOC-IF-NOT.ENV.2

 ASSOC-IF-NOT.ERROR.1 ASSOC-IF-NOT.ERROR.2 ASSOC-IF-NOT.ERROR.3

 ASSOC-IF-NOT.ERROR.4 ASSOC-IF-NOT.ERROR.5 ASSOC-IF-NOT.ERROR.6

 ASSOC-IF-NOT.ERROR.7 ASSOC-IF-NOT.ERROR.8 ASSOC-IF-NOT.ERROR.9

 ASSOC-IF-NOT.ERROR.10 ASSOC-IF-NOT.ERROR.11 ASSOC-IF-NOT.ERROR.12

 ASSOC-IF-NOT.ERROR.13 RASSOC.1 RASSOC.2 RASSOC.3 RASSOC.4 RASSOC.5

 RASSOC.6 RASSOC.7 RASSOC.8 RASSOC.9 RASSOC.10 RASSOC.11 RASSOC.12

 RASSOC.13 RASSOC.14 RASSOC.15 RASSOC.16 RASSOC.17 RASSOC.18 RASSOC.19

 RASSOC.20 RASSOC.21 RASSOC.22 RASSOC.23 RASSOC.24 RASSOC.25 RASSOC.26

 RASSOC.27 RASSOC.TEST-AND-TEST-NOT.1 RASSOC.TEST-AND-TEST-NOT.2

 RASSOC.ORDER.1 RASSOC.ORDER.2 RASSOC.ORDER.3 RASSOC.ORDER.4

 RASSOC.ALLOW-OTHER-KEYS.1 RASSOC.ALLOW-OTHER-KEYS.2

 RASSOC.ALLOW-OTHER-KEYS.3 RASSOC.ALLOW-OTHER-KEYS.4

 RASSOC.ALLOW-OTHER-KEYS.5 RASSOC.KEYWORDS.6 RASSOC.ERROR.1

 RASSOC.ERROR.2 RASSOC.ERROR.3 RASSOC.ERROR.4 RASSOC.ERROR.5

 RASSOC.ERROR.6 RASSOC.ERROR.7 RASSOC.ERROR.8 RASSOC.ERROR.9

 RASSOC.ERROR.10 RASSOCI.ERROR.11 RASSOC-IF.1 RASSOC-IF.2 RASSOC-IF.3

 RASSOC-IF.4 RASSOC-IF.ORDER.1 RASSOC-IF.ORDER.2

 RASSOC-IF.ALLOW-OTHER-KEYS.1 RASSOC-IF.ALLOW-OTHER-KEYS.2

 RASSOC-IF.ALLOW-OTHER-KEYS.3 RASSOC-IF.ALLOW-OTHER-KEYS.4

 RASSOC-IF.ALLOW-OTHER-KEYS.5 RASSOC-IF.KEYWORDS.6 RASSOC-IF.ERROR.1

 RASSOC-IF.ERROR.2 RASSOC-IF.ERROR.3 RASSOC-IF.ERROR.4 RASSOC-IF.ERROR.5

 RASSOC-IF.ERROR.6 RASSOC-IF.ERROR.7 RASSOC-IF.ERROR.8 RASSOC-IF.ERROR.9

 RASSOC-IF.ERROR.10 RASSOC-IF.ERROR.11 RASSOC-IF.ERROR.12

 RASSOC-IF-NOT.1 RASSOC-IF-NOT.2 RASSOC-IF-NOT.3 RASSOC-IF-NOT.4

 RASSOC-IF-NOT.ORDER.1 RASSOC-IF-NOT.ORDER.2

 RASSOC-IF-NOT.ALLOW-OTHER-KEYS.1 RASSOC-IF-NOT.ALLOW-OTHER-KEYS.2

 RASSOC-IF-NOT.ALLOW-OTHER-KEYS.3 RASSOC-IF-NOT.ALLOW-OTHER-KEYS.4

 RASSOC-IF-NOT.ALLOW-OTHER-KEYS.5 RASSOC-IF-NOT.ALLOW-OTHER-KEYS.6

 RASSOC-IF-NOT.KEYWORDS.7 RASSOC-IF-NOT.ERROR.1 RASSOC-IF-NOT.ERROR.2

 RASSOC-IF-NOT.ERROR.3 RASSOC-IF-NOT.ERROR.4 RASSOC-IF-NOT.ERROR.5

 RASSOC-IF-NOT.ERROR.6 RASSOC-IF-NOT.ERROR.7 RASSOC-IF-NOT.ERROR.8

 RASSOC-IF-NOT.ERROR.9 RASSOC-IF-NOT.ERROR.10 RASSOC-IF-NOT.ERROR.11

 RASSOC-IF-NOT.ERROR.12 COPY-ALIST.1 COPY-ALIST.2 COPY-ALIST.3

 COPY-ALIST.4 COPY-ALIST.ERROR.1 COPY-ALIST.ERROR.2 COPY-ALIST.ERROR.3

 PAIRLIS.1 PAIRLIS.2 PAIRLIS.3 PAIRLIS.4 PAIRLIS.FOLD.1 PAIRLIS.ERROR.1

 PAIRLIS.ERROR.2 PAIRLIS.ERROR.3 PAIRLIS.ERROR.4 PAIRLIS.ERROR.5

 PAIRLIS.ERROR.6 PAIRLIS.ERROR.7 PAIRLIS.ERROR.8 GET-PROPERTIES.1

 GET-PROPERTIES.2 GET-PROPERTIES.3 GET-PROPERTIES.4 GET-PROPERTIES.5

 GET-PROPERTIES.6 GET-PROPERTIES.7 GET-PROPERTIES.9

 GET-PROPERTIES.ORDER.1 GET-PROPERTIES.ERROR.1 GET-PROPERTIES.ERROR.2

 GET-PROPERTIES.ERROR.3 GET-PROPERTIES.ERROR.4 GET-PROPERTIES.ERROR.5

 GET-PROPERTIES.ERROR.6 GETF.1 GETF.2 GETF.3 GETF.4 GETF.5 GETF.ORDER.1

 GETF.ORDER.2 SETF-GETF.1 SETF-GETF.2 SETF-GETF.3 SETF-GETF.4

 SETF-GETF.5 SETF-GETF.ORDER.1 SETF-GETF.ORDER.2 INCF-GETF.1 INCF-GETF.2

 PUSH-GETF.1 GETF.ERROR.1 GETF.ERROR.2 GETF.ERROR.3 GETF.ERROR.4

 GETF.ERROR.5 REMF.1 REMF.2 REMF.3 REMF.4 REMF.5 REMF.6 REMF.7

 REMF.ORDER.1 REMF.ORDER.2 REMF.ORDER.3 REMF.ERROR.1 INTERSECTION.1

 INTERSECTION.2 INTERSECTION.3 INTERSECTION.4 INTERSECTION.5

 INTERSECTION.6 INTERSECTION.7 INTERSECTION.8 INTERSECTION.9

 INTERSECTION.9-A INTERSECTION.9-B INTERSECTION.10 INTERSECTION.11

 INTERSECTION.11-A INTERSECTION.12 INTERSECTION.13 INTERSECTION.13-A

 INTERSECTION.14 INTERSECTION.15 INTERSECTION.16 INTERSECTION.17

 INTERSECTION.18 INTERSECTION.TEST-AND-TEST-NOT.1

 INTERSECTION.TEST-AND-TEST-NOT.2 INTERSECTION.ORDER.1

 INTERSECTION.ORDER.2 INTERSECTION.ORDER.3 INTERSECTION.ORDER.4

 INTERSECTION.ORDER.5 INTERSECTION.ALLOW-OTHER-KEYS.1

 INTERSECTION.ALLOW-OTHER-KEYS.2 INTERSECTIONALLOW-OTHER-KEYS.3

 INTERSECTION.ALLOW-OTHER-KEYS.4 INTERSECTION.ALLOW-OTHER-KEYS.5

 INTERSECTION.ALLOW-OTHER-KEYS.6 INTERSECTION.ALLOW-OTHER-KEYS.7

 INTERSECTION.KEYWORDS.8 INTERSECTION.FOLD.1 INTERSECTION.ERROR.1

 INTERSECTION.ERROR.2 INTERSECTION.ERROR.3 INTERSECTION.ERROR.4

 INTERSECTION.ERROR.5 INTERSECTION.ERROR.6 INTERSECTION.ERROR.7

 INTERSECTION.ERROR.8 INTERSECTION.ERROR.9 INTERSECTION.ERROR.10

 INTERSECTION.ERROR.11 INTERSECTION.ERROR.12 INTERSECTION.ERROR.13

 INTERSECTION.ERROR.14 NINTERSECTION.1 NINTERSECTION.2 NINTERSECTION.3

 NINTERSECTION.4 NINTERSECTION.5 NINTERSECTION.6 NINTERSECTION.7

 NINTERSECTION.8 NINTERSECTION.9 NINTERSECTION.9-A NINTERSECTION.9-B

 NINTERSECTION.10 NINTERSECTION.11 NINTERSECTION.12 NINTERSECTION.13

 NINTERSECTION.14 NINTERSECTION.15 NINTERSECTION.16 NINTERSECTION.17

 NINTERSECTION.18 NINTERSECTION.TEST-AND-TEST-NOT.1

 NINTERSECTION.TEST-AND-TEST-NOT.2 NINTERSECTION.ORDER.1

 NINTERSECTION.ORDER.2 NINTERSECTION.ORDER.3 NINTERSECTION.ORDER.4

 NINTERSECTION.ORDER.5 NINTERSECTION.ALLOW-OTHER-KEYS.1

 NINTERSECTION.ALLOW-OTHER-KEYS.2 NINTERSECTION.ALLOW-OTHER-KEYS.3

 NINTERSECTION.ALLOW-OTHER-KEYS.4 NINTERSECTION.ALLOW-OTHER-KEYS.5

 NINTERSECTION.ALLOW-OTHER-KEYS.6 NINTERSECTION.ALLOW-OTHER-KEYS.7

 NINTERSECTION.KEYWORDS.8 NINTERSECTION.ALLOW-OTHER-KEYS.9

 NINTERSECTION.ERROR.1 NINTERSECTION.ERROR.2 NINTERSECTION.ERROR.3

 NINTERSECTION.ERROR.4 NINTERSECTION.ERROR.5 NINTERSECTION.ERROR.6

 NINTERSECTION.ERROR.7 NINTERSECTION.ERROR.8 NINTERSECTION.ERROR.9

 NINTERSECTION.ERROR.10 NINTERSECTION.ERROR.11 NINTERSECTION.ERROR.12

 NINTERSECTION.ERROR.13 NINTERSECTION.ERROR.14 UNION.1 UNION.2 UNION.3

 UNION-4 UNION.5 UNION.6 UNION.6-A UNION.7 UNION.8 UNION.9 UNION.10

 UNION.11 UNION.12 UNION.13 UNION.14 UNION.15 UNION.16 UNION.17 UNION.18

 UNION.19 UNION.20 UNION.21 UNION.22 UNION.23 UNION.24 UNION.25 UNION.26

 UNION.27 UNION.28 UNION.29 UNION.30 UNION.31 UNION.TEST-AND-TEST-NOT.1

 UNION.TEST-AND-TEST-NOT.2 UNION.ORDER.1 UNION.ORDER.2 UNION.ORDER.3

 UNION.ALLOW-OTHER-KEYS.1 UNION.ALLOW-OTHER-KEYS.2

 UNION.ALLOW-OTHER-KEYS.3 UNION.ALLOW-OTHER-KEYS.4

 UNION.ALLOW-OTHER-KEYS.5 UNION.ALLOW-OTHER-KEYS.6

 UNION.ALLOW-OTHER-KEYS.7 UNION.KEYWORDS.9 UNION.FOLD.1 UNION.ERROR.1

 UNION.ERROR.2 UNION.ERROR.3 UNION.ERROR.4 UNION.ERROR.5 UNION.ERROR.6

 UNION.ERROR.7 UNION.ERROR.8 UNION.ERROR.9 UNION.ERROR.10 UNION.ERROR.11

 UNION.ERROR.12 UNION.ERROR.13 UNION.ERROR.14 NUNION.1 NUNION.2 NUNION.3

 NUNION.4 NUNION.5 NUNION.6 NUNION.6-A NUNION.7 NUNION.8 NUNION.9

 NUNION.10 NUNION.11 NUNION.12 NUNION.13 NUNION.14 NUNION.15 NUNION.16

 NUNION.17 NUNION.18 NUNION.19 NUNION.20 NUNION.21 NUNION.22 NUNION.23

 NUNION.24 NUNION.25 NUNION.26 NUNION.27 NUNION.TEST-AND-TEST-NOT.1

 NUNION.TEST-AND-TEST-NOT.2 NUNION.28 NUNION.29 NUNION.30 NUNION.31

 NUNION.ORDER.1 NUNION.ORDER.2 NUNION.ORDER.3 NUNION.ALLOW-OTHER-KEYS.1

 NUNION.ALLOW-OTHER-KEYS.2 NUNION.ALLOW-OTHER-KEYS.3

 NUNION.ALLOW-OTHER-KEYS.4 NUNION.ALLOW-OTHER-KEYS.5

 NUNION.ALLOW-OTHER-KEYS.6 NUNION.ALLOW-OTHER-KEYS.7 NUNION.KEYWORDS.9

 NUNION.ERROR.1 NUNION.ERROR.2 NUNION.ERROR.3 NUNION.ERROR.4

 NUNION.ERROR.5 NUNION.ERROR.6 NUNION.ERROR.7 NUNION.ERROR.8

 NUNION.ERROR.9 NUNION.ERROR.10 NUNION.ERROR.11 NUNION.ERROR.12

 NUNION.ERROR.13 NUNION.ERROR.14 SET-DIFFERENCE.1 SET-DIFFERENCE.2

 SET-DIFFERENCE.3 SET-DIFFERENCE.4 SET-DIFFERENCE.5 SET-DIFFERENCE.6

 SET-DIFFERENCE.7 SET-DIFFERENCE.8 SET-DIFFERENCE.9 SET-DIFFERENCE.10

 SET-DIFFERENCE.11 SET-DIFFERENCE.12 SET-DIFFERENCE.13 SET-DIFFERENCE.14

 SET-DIFFERENCE.15 SET-DIFFERENCE.16 SET-DIFFERENCE.17 SET-DIFFERENCE.18

 SET-DIFFERENCE.19 SET-DIFFERENCE.TEST-AND-TEST-NOT.1

 SET-DIFFERENCE.TEST-AND-TEST-NOT.2 SET-DIFFERENCE.ORDER.1

 SET-DIFFERENCE.ORDER.2 SET-DIFFERENCE.ORDER.3

 SET-DIFFERENCE.ALLOW-OTHER-KEYS.1 SET-DIFFERENCE.ALLOW-OTHER-KEYS.2

 SET-DIFFERENCE.ALLOW-OTHER-KEYS.3 SET-DIFFERENCE.ALLOW-OTHER-KEYS.4

 SET-DIFFERENCE.ALLOW-OTHER-KEYS.5 SET-DIFFERENCE.ALLOW-OTHER-KEYS.6

 SET-DIFFERENCE.ALLOW-OTHER-KEYS.7 SET-DIFFERENCE.KEYWORDS.8

 SET-DIFFERENCE.KEYWORDS.9 SET-DIFFERENCE.FOLD.1 SET-DIFFERENCE.ERROR.1

 SET-DIFFERENCE.ERROR.2 SET-DIFFERENCE.ERROR.3 SET-DIFFERENCE.ERROR.4

 SET-DIFFERENCE.ERROR.5 SET-DIFFERENCE.ERROR.6 SET-DIFFERENCE.ERROR.7

 SET-DIFFERENCE.ERROR.8 SET-DIFFERENCE.ERROR.9 SET-DIFFERENCE.ERROR.10

 SET-DIFFERENCE.ERROR.11 SET-DIFFERENCE.ERROR.12 SET-DIFFERENCE.ERROR.13

 SET-DIFFERENCE.ERROR.14 NSET-DIFFERENCE.1 NSET-DIFFERENCE.2

 NSET-DIFFERENCE.3 NSET-DIFFERENCE.4 NSET-DIFFERENCE.5 NSET-DIFFERENCE.6

 NSET-DIFFERENCE.7 NSET-DIFFERENCE.8 NSET-DIFFERENCE.9

 NSET-DIFFERENCE.10 NSET-DIFFERENCE.11 NSET-DIFFERENCE.12

 NSET-DIFFERENCE.13 NSET-DIFFERENCE.14 NSET-DIFFERENCE.15

 NSET-DIFFERENCE.16 NSET-DIFFERENCE.17 NSET-DIFFERENCE.18

 NSET-DIFFERENCE.19 NSET-DIFFERENCE.TEST-AND-TEST-NOT.1

 NSET-DIFFERENCE.TEST-AND-TEST-NOT.2 NSET-DIFFERENCE.ORDER.1

 NSET-DIFFERENCE.ORDER.2 NSET-DIFFERENCE.ORDER.3

 NSET-DIFFERENCE.ALLOW-OTHER-KEYS.1 NSET-DIFFERENCE.ALLOW-OTHER-KEYS.2

 NSET-DIFFERENCE.ALLOW-OTHER-KEYS.3 NSET-DIFFERENCE.ALLOW-OTHER-KEYS.4

 NSET-DIFFERENCE.ALLOW-OTHER-KEYS.5 NSET-DIFFERENCE.ALLOW-OTHER-KEYS.6

 NSET-DIFFERENCE.ALLOW-OTHER-KEYS.7 NSET-DIFFERENCE.KEYWORDS.8

 NSET-DIFFERENCE.KEYWORDS.9 NSET-DIFFERENCE.ERROR.1

 NSET-DIFFERENCE.ERROR.2 NSET-DIFFERENCE.ERROR.3 NSET-DIFFERENCE.ERROR.4

 NSET-DIFFERENCE.ERROR.5 NSET-DIFFERENCE.ERROR.6 NSET-DIFFERENCE.ERROR.7

 NSET-DIFFERENCE.ERROR.8 NSET-DIFFERENCE.ERROR.9

 NSET-DIFFERENCE.ERROR.10 NSET-DIFFERENCE.ERROR.11

 NSET-DIFFERENCE.ERROR.12 NSET-DIFFERENCE.ERROR.13

 NSET-DIFFERENCE.ERROR.14 SET-EXCLUSIVE-OR.1 SET-EXCLUSIVE-OR.2

 SET-EXCLUSIVE-OR.3 SET-EXCLUSIVE-OR.4 SET-EXCLUSIVE-OR.5

 SET-EXCLUSIVE-OR.6 SET-EXCLUSIVE-OR.7 SET-EXCLUSIVE-OR.7-A

 SET-EXCLUSIVE-OR.8 SET-EXCLUSIVE-OR.8-A SET-EXCLUSIVE-OR.8-B

 SET-EXCLUSIVE-OR.9 SET-EXCLUSIVE-OR.10 SET-EXCLUSIVE-OR.11

 SET-EXCLUSIVE-OR.12 SET-EXCLUSIVE-OR.14 SET-EXCLUSIVE-OR.15

 SET-EXCLUSIVE-OR.16 SET-EXCLUSIVE-OR.17 SET-EXCLUSIVE-OR.17-A

 SET-EXCLUSIVE-OR.18 SET-EXCLUSIVE-OR.18-A

 SET-EXCLUSIVE-OR.TEST-AND-TEST-NOT.1

 SET-EXCLUSIVE-OR.TEST-AND-TEST-NOT.2 SET-EXCLUSIVE-OR.ORDER.1

 SET-EXCLUSIVE-OR.ORDER.2 SET-EXCLUSIVE-OR.ORDER.3

 SET-EXCLUSIVE-OR.ORDER.4 SET-EXCLUSIVE-OR.ORDER.5

 SET-EXCLUSIVE.ALLOW-OTHER-KEYS.1 SET-EXCLUSIVE.ALLOW-OTHER-KEYS.2

 SET-EXCLUSIVE.ALLOW-OTHER-KEYS.3 SET-EXCLUSIVE.ALLOW-OTHER-KEYS.4

 SET-EXCLUSIVE.ALLOW-OTHER-KEYS.5 SET-EXCLUSIVE.ALLOW-OTHER-KEYS.6

 SET-EXCLUSIVE.ALLOW-OTHER-KEYS.7 SET-EXCLUSIVE.KEYWORDS.8

 SET-EXCLUSIVE.KEYWORDS.9 SET-EXCLUSIVE-OR.FOLD.1

 SET-EXCLUSIVE-OR.ERROR.1 SET-EXCLUSIVE-OR.ERROR.2

 SET-EXCLUSIVE-OR.ERROR.3 SET-EXCLUSIVE-OR.ERROR.4

 SET-EXCLUSIVE-OR.ERROR.5 SET-EXCLUSIVE-OR.ERROR.6

 SET-EXCLUSIVE-OR.ERROR.7 SET-EXCLUSIVE-OR.ERROR.8

 SET-EXCLUSIVE-OR.ERROR.9 SET-EXCLUSIVE-OR.ERROR.10

 SET-EXCLUSIVE-OR.ERROR.11 SET-EXCLUSIVE-OR.ERROR.12

 SET-EXCLUSIVE-OR.ERROR.13 SET-EXCLUSIVE-OR.ERROR.14

 RANDOM-SET-EXCLUSIVE-OR NSET-EXCLUSIVE-OR.1 NSET-EXCLUSIVE-OR.2

 NSET-EXCLUSIVE-OR.3 NSET-EXCLUSIVE-OR.4 NSET-EXCLUSIVE-OR.5

 NSET-EXCLUSIVE-OR.6 NSET-EXCLUSIVE-OR.7 NSET-EXCLUSIVE-OR.7-A

 NSET-EXCLUSIVE-OR.8 NSET-EXCLUSIVE-OR.8-A NSET-EXCLUSIVE-OR.8-B

 NSET-EXCLUSIVE-OR.9 NSET-EXCLUSIVE-OR.10 NSET-EXCLUSIVE-OR.11

 NSET-EXCLUSIVE-OR.12 NSET-EXCLUSIVE-OR.14 NSET-EXCLUSIVE-OR.15

 NSET-EXCLUSIVE-OR.16 NSET-EXCLUSIVE-OR.17 NSET-EXCLUSIVE-OR.17-A

 NSET-EXCLUSIVE-OR.18 NSET-EXCLUSIVE-OR.18-A

 NSET-EXCLUSIVE-OR.TEST-AND-TEST-NOT.1

 NSET-EXCLUSIVE-OR.TEST-AND-TEST-NOT.2 NSET-EXCLUSIVE-OR.ORDER.1

 NSET-EXCLUSIVE-OR.ORDER.2 NSET-EXCLUSIVE-OR.ORDER.3

 NSET-EXCLUSIVE-OR.ORDER.4 NSET-EXCLUSIVE-OR.ORDER.5

 NSET-EXCLUSIVE.ALLOW-OTHER-KEYS.1 NSET-EXCLUSIVE.ALLOW-OTHER-KEYS.2

 NSET-EXCLUSIVE.ALLOW-OTHER-KEYS.3 NSET-EXCLUSIVE.ALLOW-OTHER-KEYS.4

 NSET-EXCLUSIVE.ALLOW-OTHER-KEYS.5 NSET-EXCLUSIVE.ALLOW-OTHER-KEYS.6

 NSET-EXCLUSIVE.ALLOW-OTHER-KEYS.7 NSET-EXCLUSIVE.KEYWORDS.8

 NSET-EXCLUSIVE.KEYWORDS.9 RANDOM-NSET-EXCLUSIVE-OR

 NSET-EXCLUSIVE-OR.ERROR.1 NSET-EXCLUSIVE-OR.ERROR.2

 NSET-EXCLUSIVE-OR.ERROR.3 NSET-EXCLUSIVE-OR.ERROR.4

 NSET-EXCLUSIVE-OR.ERROR.5 NSET-EXCLUSIVE-OR.ERROR.6

 NSET-EXCLUSIVE-OR.ERROR.7 NSET-EXCLUSIVE-OR.ERROR.8

 NSET-EXCLUSIVE-OR.ERROR.9 NSET-EXCLUSIVE-OR.ERROR.10

 NSET-EXCLUSIVE-OR.ERROR.11 NSET-EXCLUSIVE-OR.ERROR.12

 NSET-EXCLUSIVE-OR.ERROR.13 NSET-EXCLUSIVE-OR.ERROR.14 SUBSETP.1

 SUBSETP.2 SUBSETP.3 SUBSETP.4 SUBSETP.5 SUBSETP.6 SUBSETP.7 SUBSETP.8

 SUBSETP.9 SUBSETP.10 SUBSETP.11 SUBSETP.12 SUBSETP.13 SUBSETP.14

 SUBSETP.15 SUBSETP.TEST-AND-TEST-NOT.1 SUBSETP.TEST-AND-TEST-NOT.3

 SUBSETP.ORDER.1 SUBSETP.ORDER.2 SUBSETP.ORDER.3

 SUBSETP.ALLOW-OTHER-KEYS.1 SUBSETP.ALLOW-OTHER-KEYS.2

 SUBSETP.ALLOW-OTHER-KEYS.3 SUBSETP.ALLOW-OTHER-KEYS.4

 SUBSETP.ALLOW-OTHER-KEYS.5 SUBSETP.ALLOW-OTHER-KEYS.6

 SUBSETP.KEYWORDS.7 SUBSETP.KEYWORDS.8 SUBSETP.ERROR.1 SUBSETP.ERROR.2

 SUBSETP.ERROR.3 SUBSETP.ERROR.4 SUBSETP.ERROR.5 SUBSETP.ERROR.6

 SUBSETP.ERROR.7 SUBSETP.ERROR.8 SUBSETP.ERROR.9 SUBSETP.ERROR.10

 SUBSETP.ERROR.11 SUBSETP.ERROR.12 SUBSETP.ERROR.13 SUBSETP.ERROR.14

 SUBTYPEP-NULL-LIST SUBTYPEP-CONS-LIST SUBTYPEP-NULL-CONS

 SUBTYPEP-CONS-NULL SUBTYPEP-NULL-ATOM SUBTYPEP-CONS-ATOM

 SUBTYPEP-ATOM-CONS SUBTYPEP-ATOM-LIST SUBTYPEP-LIST-ATOM

 NULL-NULL-UNIVERSE FUNCTION-BOUND-CONS-FNS MACRO-BOUND-CONS-MACROS

 NO-CONS-FNS-ARE-MACROS TYPEP-NIL-LIST TYPEP-SYMBOL-LIST

 TYPEP-SINGLETON-LIST-LIST TYPEP-CIRCULAR-LIST-LIST

 TYPEP-LONGER-LIST-LIST FIRST-ETC-1 FIRST-ETC-2 REST-SET-1 CAR-SET

 CDR-SET CAAR-SET CADR-SET CDAR-SET CDDR-SET CAAAR-SET CAADR-SET

 CADAR-SET CADDR-SET CDAAR-SET CDADR-SET CDDAR-SET CDDDR-SET CAAAAR-SET

 CAAADR-SET CAADAR-SET CAADDR-SET CADAAR-SET CADADR-SET CADDAR-SET

 CADDDR-SET CDAAAR-SET CDAADR-SET CDADAR-SET CDADDR-SET CDDAAR-SET

 CDDADR-SET CDDDAR-SET CDDDDR-SET FIRST-SET SECOND-SET THIRD-SET

 FOURTH-SET FIFTH-SET SIXTH-SET SEVENTH-SET EIGHTH-SET NINTH-SET

 TENTH-SET FIRST.ERROR.NO-ARGS FIRST.ERROR.EXCESS-ARGS

 SECOND.ERROR.NO-ARGS SECOND.ERROR.EXCESS-ARGS THIRD.ERROR.NO-ARGS

 THIRD.ERROR.EXCESS-ARGS FOURTH.ERROR.NO-ARGS FOURTH.ERROR.EXCESS-ARGS

 FIFTH.ERROR.NO-ARGS FIFTH.ERROR.EXCESS-ARGS SIXTH.ERROR.NO-ARGS

 SIXTH.ERROR.EXCESS-ARGS SEVENTH.ERROR.NO-ARGS SEVENTH.ERROR.EXCESS-ARGS

 EIGHTH.ERROR.NO-ARGS EIGHTH.ERROR.EXCESS-ARGS NINTH.ERROR.NO-ARGS

 NINTH.ERROR.EXCESS-ARGS TENTH.ERROR.NO-ARGS TENTH.ERROR.EXCESS-ARGS

 CAR.ERROR.NO-ARGS CAR.ERROR.EXCESS-ARGS CDR.ERROR.NO-ARGS

 CDR.ERROR.EXCESS-ARGS CAAR.ERROR.NO-ARGS CAAR.ERROR.EXCESS-ARGS

 CADR.ERROR.NO-ARGS CADR.ERROR.EXCESS-ARGS CDAR.ERROR.NO-ARGS

 CDAR.ERROR.EXCESS-ARGS CDDR.ERROR.NO-ARGS CDDR.ERROR.EXCESS-ARGS

 CAAAR.ERROR.NO-ARGS CAAAR.ERROR.EXCESS-ARGS CAADR.ERROR.NO-ARGS

 CAADR.ERROR.EXCESS-ARGS CADAR.ERROR.NO-ARGS CADAR.ERROR.EXCESS-ARGS

 CADDR.ERROR.NO-ARGS CADDR.ERROR.EXCESS-ARGS CDAAR.ERROR.NO-ARGS

 CDAAR.ERROR.EXCESS-ARGS CDADR.ERROR.NO-ARGS CDADR.ERROR.EXCESS-ARGS

 CDDAR.ERROR.NO-ARGS CDDAR.ERROR.EXCESS-ARGS CDDDR.ERROR.NO-ARGS

 CDDDR.ERROR.EXCESS-ARGS CAAAAR.ERROR.NO-ARGS CAAAAR.ERROR.EXCESS-ARGS

 CAAADR.ERROR.NO-ARGS CAAADR.ERROR.EXCESS-ARGS CAADAR.ERROR.NO-ARGS

 CAADAR.ERROR.EXCESS-ARGS CAADDR.ERROR.NO-ARGS CAADDR.ERROR.EXCESS-ARGS

 CADAAR.ERROR.NO-ARGS CADAAR.ERROR.EXCESS-ARGS CADADR.ERROR.NO-ARGS

 CADADR.ERROR.EXCESS-ARGS CADDAR.ERROR.NO-ARGS CADDAR.ERROR.EXCESS-ARGS

 CADDDR.ERROR.NO-ARGS CADDDR.ERROR.EXCESS-ARGS CDAAAR.ERROR.NO-ARGS

 CDAAAR.ERROR.EXCESS-ARGS CDAADR.ERROR.NO-ARGS CDAADR.ERROR.EXCESS-ARGS

 CDADAR.ERROR.NO-ARGS CDADAR.ERROR.EXCESS-ARGS CDADDR.ERROR.NO-ARGS

 CDADDR.ERROR.EXCESS-ARGS CDDAAR.ERROR.NO-ARGS CDDAAR.ERROR.EXCESS-ARGS

 CDDADR.ERROR.NO-ARGS CDDADR.ERROR.EXCESS-ARGS CDDDAR.ERROR.NO-ARGS

 CDDDAR.ERROR.EXCESS-ARGS CDDDDR.ERROR.NO-ARGS CDDDDR.ERROR.EXCESS-ARGS

 AREF.1 AREF.2 AREF.3 AREF.4 AREF.5 AREF.6 AREF.7 AREF.ORDER.1

 AREF.ORDER.2 SETF-AREF.1 SETF-AREF.2 SETF-AREF.3 SETF-AREF.4

 SETF-AREF.5 SETF-AREF.6 SETF-AREF.7 SETF-AREF.ORDER.1

 AREF.SPECIAL-INTEGER.1 AREF.SPECIAL-STRINGS.1 AREF.ERROR.1 AREF.ERROR.2

 ARRAY.1.1 ARRAY.1.2 ARRAY.1.3 ARRAY.1.4 ARRAY.1.5 ARRAY.1.6 ARRAY.1.7

 ARRAY.1.8 ARRAY.1.9 ARRAY.1.10 ARRAY.1.11 ARRAY.1.12 ARRAY.1.13

 ARRAY.2.1 ARRAY.2.2 ARRAY.2.3 ARRAY.2.4 ARRAY.2.5 ARRAY.2.6 ARRAY.3.1

 ARRAY.3.2 ARRAY.3.3 ARRAY.3.4 ARRAY.3.5 ARRAY.3.6 ARRAY.4.1 ARRAY.4.2

 ARRAY.4.3 ARRAY.4.4 ARRAY.4.5 ARRAY.4.6 ARRAY.5.1 ARRAY.5.2 ARRAY.5.3

 ARRAY.5.4 ARRAY.5.5 ARRAY.5.6 ARRAY.6.1 ARRAY.6.2 ARRAY.6.3 ARRAY.6.4

 ARRAY.6.5 ARRAY.6.6 ARRAY.7.1 ARRAY.7.2 ARRAY.7.3 ARRAY.7.4 ARRAY.7.5

 ARRAY.7.6 ARRAY.8.1 ARRAY.8.2 ARRAY.8.3 ARRAY.8.4 ARRAY.8.5 ARRAY.8.6

 ARRAY.8.7 ARRAY.8.8 ARRAY.8.9 ARRAY.8.10 ARRAY.8.11 ARRAY.8.12

 ARRAY.8.13 ARRAY.8.14 ARRAY.9.1 ARRAY.9.2 ARRAY.9.3 ARRAY.9.4 ARRAY.9.5

 ARRAY.9.6 ARRAY.9.7 ARRAY.9.8 ARRAY.9.9 ARRAY.9.10 ARRAY.9.11

 ARRAY.9.12 ARRAY.9.13 ARRAY-T.2.1 ARRAY-T.2.2 ARRAY-T.2.3 ARRAY-T.2.4

 ARRAY-T.2.5 ARRAY-T.2.6 ARRAY-T.3.1 ARRAY-T.3.2 ARRAY-T.3.3 ARRAY-T.3.4

 ARRAY-T.3.5 ARRAY-T.3.6 ARRAY-T.4.1 ARRAY-T.4.2 ARRAY-T.4.3 ARRAY-T.4.4

 ARRAY-T.4.5 ARRAY-T.4.6 ARRAY-T.5.1 ARRAY-T.5.2 ARRAY-T.5.3 ARRAY-T.5.4

 ARRAY-T.5.5 ARRAY-T.5.6 ARRAY-T.6.1 ARRAY-T.6.2 ARRAY-T.6.3 ARRAY-T.6.4

 ARRAY-T.6.5 ARRAY-T.6.6 ARRAY-T.7.1 ARRAY-T.7.2 ARRAY-T.7.3 ARRAY-T.7.4

 ARRAY-T.7.5 ARRAY-T.7.6 ARRAY-T.8.1 ARRAY-T.8.2 ARRAY-T.8.3 ARRAY-T.8.4

 ARRAY-T.8.5 ARRAY-T.8.6 ARRAY-T.8.7 ARRAY-T.8.8 ARRAY-T.8.9

 ARRAY-T.8.10 ARRAY-T.8.11 ARRAY-T.8.12 ARRAY-T.8.13 ARRAY-T.8.14

 ARRAY-T.9.1 ARRAY-T.9.2 ARRAY-T.9.3 ARRAY-T.9.4 ARRAY-T.9.5 ARRAY-T.9.6

 ARRAY-T.9.7 ARRAY-T.9.8 ARRAY-T.9.9 ARRAY-T.9.10 ARRAY-T.9.11

 ARRAY-T.9.12 ARRAY-T.9.13 ARRAY-AS-CLASS.1 ARRAY-AS-CLASS.2

 ARRAY-AS-CLASS.3 ARRAY-AS-CLASS.4 ARRAY-AS-CLASS.5 ARRAY-AS-CLASS.6

 ARRAY-AS-CLASS.7 ARRAY-AS-CLASS.8 ARRAY-AS-CLASS.9 ARRAY-AS-CLASS.10

 ARRAY-AS-CLASS.11 ARRAY-AS-CLASS.12 ARRAY-AS-CLASS.13 ARRAY-AS-CLASS.14

 ARRAY-AS-CLASS.15 SIMPLE-ARRAY.1.1 SIMPLE-ARRAY.1.2 SIMPLE-ARRAY.1.3

 SIMPLE-ARRAY.1.4 SIMPLE-ARRAY.1.5 SIMPLE-ARRAY.1.6 SIMPLE-ARRAY.1.7

 SIMPLE-ARRAY.1.8 SIMPLE-ARRAY.1.9 SIMPLE-ARRAY.1.10 SIMPLE-ARRAY.1.11

 SIMPLE-ARRAY.1.12 SIMPLE-ARRAY.1.13 SIMPLE-ARRAY.2.1 SIMPLE-ARRAY.2.2

 SIMPLE-ARRAY.2.3 SIMPLE-ARRAY.2.4 SIMPLE-ARRAY.2.5 SIMPLE-ARRAY.2.6

 SIMPLE-ARRAY.3.1 SIMPLE-ARRAY.3.2 SIMPLE-ARRAY.3.3 SIMPLE-ARRAY.3.4

 SIMPLE-ARRAY.3.5 SIMPLE-ARRAY.3.6 SIMPLE-ARRAY.4.1 SIMPLE-ARRAY.4.2

 SIMPLE-ARRAY.4.3 SIMPLE-ARRAY.4.4 SIMPLE-ARRAY.4.5 SIMPLE-ARRAY.4.6

 SIMPLE-ARRAY.5.1 SIMPLE-ARRAY.5.2 SIMPLE-ARRAY.5.3 SIMPLE-ARRAY.5.4

 SIMPLE-ARRAY.5.5 SIMPLE-ARRAY.5.6 SIMPLE-ARRAY.6.1 SIMPLE-ARRAY.6.2

 SIMPLE-ARRAY.6.3 SIMPLE-ARRAY.6.4 SIMPLE-ARRAY.6.5 SIMPLE-ARRAY.6.6

 SIMPLE-ARRAY.7.1 SIMPLE-ARRAY.7.2 SIMPLE-ARRAY.7.3 SIMPLE-ARRAY.7.4

 SIMPLE-ARRAY.7.5 SIMPLE-ARRAY.7.6 SIMPLE-ARRAY.8.1 SIMPLE-ARRAY.8.2

 SIMPLE-ARRAY.8.3 SIMPLE-ARRAY.8.4 SIMPLE-ARRAY.8.5 SIMPLE-ARRAY.8.6

 SIMPLE-ARRAY.8.7 SIMPLE-ARRAY.8.8 SIMPLE-ARRAY.8.9 SIMPLE-ARRAY.8.10

 SIMPLE-ARRAY.8.11 SIMPLE-ARRAY.8.12 SIMPLE-ARRAY.8.13 SIMPLE-ARRAY.8.14

 SIMPLE-ARRAY.9.1 SIMPLE-ARRAY.9.2 SIMPLE-ARRAY.9.3 SIMPLE-ARRAY.9.4

 SIMPLE-ARRAY.9.5 SIMPLE-ARRAY.9.6 SIMPLE-ARRAY.9.7 SIMPLE-ARRAY.9.8

 SIMPLE-ARRAY.9.9 SIMPLE-ARRAY.9.10 SIMPLE-ARRAY.9.11 SIMPLE-ARRAY.9.12

 SIMPLE-ARRAY.9.13 SIMPLE-ARRAY-T.2.1 SIMPLE-ARRAY-T.2.2

 SIMPLE-ARRAY-T.2.3 SIMPLE-ARRAY-T.2.4 SIMPLE-ARRAY-T.2.5

 SIMPLE-ARRAY-T.2.6 SIMPLE-ARRAY-T.3.1 SIMPLE-ARRAY-T.3.2

 SIMPLE-ARRAY-T.3.3 SIMPLE-ARRAY-T.3.4 SIMPLE-ARRAY-T.3.5

 SIMPLE-ARRAY-T.3.6 SIMPLE-ARRAY-T.4.1 SIMPLE-ARRAY-T.4.2

 SIMPLE-ARRAY-T.4.3 SIMPLE-ARRAY-T.4.4 SIMPLE-ARRAY-T.4.5

 SIMPLE-ARRAY-T.4.6 SIMPLE-ARRAY-T.5.1 SIMPLE-ARRAY-T.5.2

 SIMPLE-ARRAY-T.5.3 SIMPLE-ARRAY-T.5.4 SIMPLE-ARRAY-T.5.5

 SIMPLE-ARRAY-T.5.6 SIMPLE-ARRAY-T.6.1 SIMPLE-ARRAY-T.6.2

 SIMPLE-ARRAY-T.6.3 SIMPLE-ARRAY-T.6.4 SIMPLE-ARRAY-T.6.5

 SIMPLE-ARRAY-T.6.6 SIMPLE-ARRAY-T.7.1 SIMPLE-ARRAY-T.7.2

 SIMPLE-ARRAY-T.7.3 SIMPLE-ARRAY-T.7.4 SIMPLE-ARRAY-T.7.5

 SIMPLE-ARRAY-T.7.6 SIMPLE-ARRAY-T.8.1 SIMPLE-ARRAY-T.8.2

 SIMPLE-ARRAY-T.8.3 SIMPLE-ARRAY-T.8.4 SIMPLE-ARRAY-T.8.5

 SIMPLE-ARRAY-T.8.6 SIMPLE-ARRAY-T.8.7 SIMPLE-ARRAY-T.8.8

 SIMPLE-ARRAY-T.8.9 SIMPLE-ARRAY-T.8.10 SIMPLE-ARRAY-T.8.11

 SIMPLE-ARRAY-T.8.12 SIMPLE-ARRAY-T.8.13 SIMPLE-ARRAY-T.8.14

 SIMPLE-ARRAY-T.9.1 SIMPLE-ARRAY-T.9.2 SIMPLE-ARRAY-T.9.3

 SIMPLE-ARRAY-T.9.4 SIMPLE-ARRAY-T.9.5 SIMPLE-ARRAY-T.9.6

 SIMPLE-ARRAY-T.9.7 SIMPLE-ARRAY-T.9.8 SIMPLE-ARRAY-T.9.9

 SIMPLE-ARRAY-T.9.10 SIMPLE-ARRAY-T.9.11 SIMPLE-ARRAY-T.9.12

 SIMPLE-ARRAY-T.9.13 BIT-VECTOR.1 BIT-VECTOR.2 BIT-VECTOR.3 BIT-VECTOR.4

 BIT-VECTOR.5 BIT-VECTOR.6 BIT-VECTOR.7 BIT-VECTOR.8 BIT-VECTOR.9

 BIT-VECTOR.10 BIT-VECTOR.11 BIT-VECTOR.12 BIT-VECTOR.13 BIT-VECTOR.14

 BIT-VECTOR.15 BIT-VECTOR.16 BIT-VECTOR.17 BIT-VECTOR.CLASS.2

 BIT-VECTOR.CLASS.3 BIT-VECTOR.CLASS.4 BIT-VECTOR.CLASS.5

 BIT-VECTOR.CLASS.6 BIT-VECTOR.CLASS.7 BIT-VECTOR.CLASS.8

 BIT-VECTOR.CLASS.9 BIT-VECTOR.CLASS.10 BIT-VECTOR.CLASS.11

 SIMPLE-BIT-VECTOR.2 SIMPLE-BIT-VECTOR.3 SIMPLE-BIT-VECTOR.4

 SIMPLE-BIT-VECTOR.5 SIMPLE-BIT-VECTOR.6 SIMPLE-BIT-VECTOR.7

 SIMPLE-BIT-VECTOR.8 SIMPLE-BIT-VECTOR.9 SIMPLE-BIT-VECTOR.10

 SIMPLE-BIT-VECTOR.11 SIMPLE-BIT-VECTOR.12 SIMPLE-BIT-VECTOR.13

 SIMPLE-BIT-VECTOR.14 SIMPLE-BIT-VECTOR.15 SIMPLE-BIT-VECTOR.16

 SIMPLE-BIT-VECTOR.17 MAKE-ARRAY.1 MAKE-ARRAY.1A MAKE-ARRAY.2

 MAKE-ARRAY.2A MAKE-ARRAY.2B MAKE-ARRAY.2C MAKE-ARRAY.2D MAKE-ARRAY.3

 MAKE-ARRAY.4 MAKE-ARRAY.4A MAKE-ARRAY.4B MAKE-ARRAY.4C MAKE-ARRAY.5

 MAKE-ARRAY.5A MAKE-ARRAY.6 MAKE-ARRAY.6A MAKE-ARRAY.6B MAKE-ARRAY.7

 MAKE-ARRAY.7A MAKE-ARRAY.7B MAKE-ARRAY.8 MAKE-ARRAY.8A MAKE-ARRAY.8B

 MAKE-ARRAY.8C MAKE-ARRAY.8D MAKE-ARRAY.8E MAKE-ARRAY.8F MAKE-ARRAY.9

 MAKE-ARRAY.10 MAKE-ARRAY.11 MAKE-ARRAY.12 MAKE-ARRAY.12A MAKE-ARRAY.12B

 MAKE-ARRAY.12C MAKE-ARRAY.13 MAKE-ARRAY.14 MAKE-ARRAY.15 MAKE-ARRAY.16

 MAKE-ARRAY.17 MAKE-ARRAY.18 MAKE-ARRAY.19 MAKE-ARRAY.20 MAKE-ARRAY.21

 MAKE-ARRAY.22 MAKE-ARRAY.23 MAKE-ARRAY.25 MAKE-ARRAY.26 MAKE-ARRAY.27

 MAKE-ARRAY.28 MAKE-ARRAY.29 MAKE-ARRAY.30 MAKE-ARRAY.31 MAKE-ARRAY.32

 MAKE-ARRAY.33 MAKE-ARRAY.34 MAKE-ARRAY.35 MAKE-ARRAY.36

 MAKE-ARRAY.ADJUSTABLE.1 MAKE-ARRAY.ADJUSTABLE.2 MAKE-ARRAY.ADJUSTABLE.3

 MAKE-ARRAY.ADJUSTABLE.4 MAKE-ARRAY.ADJUSTABLE.5 MAKE-ARRAY.ADJUSTABLE.6

 MAKE-ARRAY.ADJUSTABLE.7 MAKE-ARRAY.ADJUSTABLE.7A

 MAKE-ARRAY.ADJUSTABLE.7B MAKE-ARRAY.ADJUSTABLE.7C

 MAKE-ARRAY.ADJUSTABLE.8 MAKE-ARRAY.ADJUSTABLE.9

 MAKE-ARRAY.ADJUSTABLE.10 MAKE-ARRAY.ADJUSTABLE.11

 MAKE-ARRAY.DISPLACED.1 MAKE-ARRAY.DISPLACED.2 MAKE-ARRAY.DISPLACED.3

 MAKE-ARRAY.DISPLACED.4 MAKE-ARRAY.DISPLACED.5 MAKE-ARRAY.DISPLACED.6

 MAKE-ARRAY.DISPLACED.7 MAKE-ARRAY.DISPLACED.8 MAKE-ARRAY.DISPLACED.9

 MAKE-ARRAY.DISPLACED.10 MAKE-ARRAY.DISPLACED.11 MAKE-ARRAY.DISPLACED.12

 MAKE-ARRAY.DISPLACED.13 MAKE-ARRAY.DISPLACED.14 MAKE-ARRAY.DISPLACED.15

 MAKE-ARRAY.DISPLACED.16 MAKE-ARRAY.DISPLACED.17 MAKE-ARRAY.DISPLACED.18

 MAKE-ARRAY.DISPLACED.19 MAKE-ARRAY.DISPLACED.20 MAKE-ARRAY.DISPLACED.21

 MAKE-ARRAY.DISPLACED.22 MAKE-ARRAY.DISPLACED.23 MAKE-ARRAY.DISPLACED.24

 MAKE-ARRAY.DISPLACED.25 MAKE-ARRAY.DISPLACED.26 MAKE-ARRAY.DISPLACED.27

 MAKE-ARRAY.DISPLACED.28 MAKE-ARRAY.DISPLACED.29 MAKE-ARRAY.DISPLACED.30

 MAKE-ARRAY.DISPLACED.31 MAKE-ARRAY.ALLOW-OTHER-KEYS.1

 MAKE-ARRAY.ALLOW-OTHER-KEYS.2 MAKE-ARRAY.ALLOW-OTHER-KEYS.3

 MAKE-ARRAY.ALLOW-OTHER-KEYS.4 MAKE-ARRAY.ALLOW-OTHER-KEYS.5

 MAKE-ARRAY.ALLOW-OTHER-KEYS.6 MAKE-ARRAY.ALLOW-OTHER-KEYS.7

 MAKE-ARRAY.KEYWORDS.8. MAKE-ARRAY.ERROR.1 MAKE-ARRAY.ERROR.2

 MAKE-ARRAY.ERROR.3 MAKE-ARRAY.ERROR.4 MAKE-ARRAY.ERROR.5

 MAKE-ARRAY.ERROR.6 MAKE-ARRAY.ORDER.1 MAKE-ARRAY.ORDER.2 ADJUST-ARRAY.1

 ADJUST-ARRAY.2 ADJUST-ARRAY.3 ADJUST-ARRAY.4 ADJUST-ARRAY.5

 ADJUST-ARRAY.6 ADJUST-ARRAY.7 ADJUST-ARRAY.8 ADJUST-ARRAY.9

 ADJUST-ARRAY.10 ADJUST-ARRAY.11 ADJUST-ARRAY.12 ADJUST-ARRAY.13

 ADJUST-ARRAY.14 ADJUST-ARRAY.15 ADJUST-ARRAY.16 ADJUST-ARRAY.17

 ADJUST-ARRAY.18 ADJUST-ARRAY.19 ADJUST-ARRAY.20 ADJUST-ARRAY.21

 ADJUST-ARRAY.22 ADJUST-ARRAY.23 ADJUST-ARRAY.24 ADJUST-ARRAY.25

 ADJUST-ARRAY.26 ADJUST-ARRAY.27 ADJUST-ARRAY.28 ADJUST-ARRAY.29

 ADJUST-ARRAY.30 ADJUST-ARRAY.31 ADJUST-ARRAY.32 ADJUST-ARRAY.33

 ADJUST-ARRAY.34 ADJUST-ARRAY.35 ADJUST-ARRAY.36 ADJUST-ARRAY.37

 ADJUST-ARRAY.ADJUSTABLE.1 ADJUST-ARRAY.ADJUSTABLE.2

 ADJUST-ARRAY.ADJUSTABLE.3 ADJUST-ARRAY.ADJUSTABLE.4

 ADJUST-ARRAY.ADJUSTABLE.5 ADJUST-ARRAY.ADJUSTABLE.6

 ADJUST-ARRAY.ADJUSTABLE.7 ADJUST-ARRAY.ADJUSTABLE.8

 ADJUST-ARRAY.ADJUSTABLE.9 ADJUST-ARRAY.ADJUSTABLE.10

 ADJUST-ARRAY.ADJUSTABLE.11 ADJUST-ARRAY.ADJUSTABLE.12

 ADJUST-ARRAY.ADJUSTABLE.13 ADJUST-ARRAY.STRING.1 ADJUST-ARRAY.STRING.2

 ADJUST-ARRAY.STRING.3 ADJUST-ARRAY.STRING.4 ADJUST-ARRAY.STRING.5

 ADJUST-ARRAY.STRING.6 ADJUST-ARRAY.STRING.7 ADJUST-ARRAY.STRING.8

 ADJUST-ARRAY.STRING.9 ADJUST-ARRAY.STRING.10 ADJUST-ARRAY.STRING.11

 ADJUST-ARRAY.STRING.12 ADJUST-ARRAY.STRING.13 ADJUST-ARRAY.STRING.14

 ADJUST-ARRAY.STRING.15 ADJUST-ARRAY.STRING.16 ADJUST-ARRAY.STRING.17

 ADJUST-ARRAY.STRING.18 ADJUST-ARRAY.STRING.19 ADJUST-ARRAY.STRING.20

 ADJUST-ARRAY.STRING.ADJUSTABLE.1 ADJUST-ARRAY.STRING.ADJUSTABLE.2

 ADJUST-ARRAY.STRING.ADJUSTABLE.3 ADJUST-ARRAY.STRING.ADJUSTABLE.4

 ADJUST-ARRAY.STRING.ADJUSTABLE.5 ADJUST-ARRAY.STRING.ADJUSTABLE.6

 ADJUST-ARRAY.STRING.ADJUSTABLE.7 ADJUST-ARRAY.STRING.ADJUSTABLE.8

 ADJUST-ARRAY.STRING.ADJUSTABLE.9 ADJUST-ARRAY.STRING.ADJUSTABLE.10

 ADJUST-ARRAY.STRING.ADJUSTABLE.11 ADJUST-ARRAY.STRING.ADJUSTABLE.12

 ADJUST-ARRAY.STRING.ADJUSTABLE.13 ADJUST-ARRAY.BASEST.1

 ADJUST-ARRAY.BASEST.2 ADJUST-ARRAY.BASEST.3 ADJUST-ARRAY.BASEST.4

 ADJUST-ARRAY.BASEST.5 ADJUST-ARRAY.BASEST.6 ADJUST-ARRAY.BASEST.7

 ADJUST-ARRAY.BASEST.8 ADJUST-ARRAY.BASEST.9 ADJUST-ARRAY.BASEST.10

 ADJUST-ARRAY.BASEST.11 ADJUST-ARRAY.BASEST.12 ADJUST-ARRAY.BASEST.13

 ADJUST-ARRAY.BASEST.14 ADJUST-ARRAY.BASEST.15 ADJUST-ARRAY.BASEST.16

 ADJUST-ARRAY.BASEST.17 ADJUST-ARRAY.BASEST.18 ADJUST-ARRAY.BASEST.19

 ADJUST-ARRAY.BASEST.20 ADJUST-ARRAY.BASEST.ADJUSTABLE.1

 ADJUST-ARRAY.BASEST.ADJUSTABLE.2 ADJUST-ARRAY.BASEST.ADJUSTABLE.3

 ADJUST-ARRAY.BASEST.ADJUSTABLE.4 ADJUST-ARRAY.BASEST.ADJUSTABLE.5

 ADJUST-ARRAY.BASEST.ADJUSTABLE.6 ADJUST-ARRAY.BASEST.ADJUSTABLE.7

 ADJUST-ARRAY.BASEST.ADJUSTABLE.8 ADJUST-ARRAY.BASEST.ADJUSTABLE.9

 ADJUST-ARRAY.BASEST.ADJUSTABLE.10 ADJUST-ARRAY.BASEST.ADJUSTABLE.11

 ADJUST-ARRAY.BASEST.ADJUSTABLE.12 ADJUST-ARRAY.BASEST.ADJUSTABLE.13

 ADJUST-ARRAY.STRING.21 ADJUST-ARRAY.STRING.22 ADJUST-ARRAY.BIT-VECTOR.1

 ADJUST-ARRAY.BIT-VECTOR.2 ADJUST-ARRAY.BIT-VECTOR.3

 ADJUST-ARRAY.BIT-VECTOR.4 ADJUST-ARRAY.BIT-VECTOR.5

 ADJUST-ARRAY.BIT-VECTOR.6 ADJUST-ARRAY.BIT-VECTOR.7

 ADJUST-ARRAY.BIT-VECTOR.8 ADJUST-ARRAY.BIT-VECTOR.9

 ADJUST-ARRAY.BIT-VECTOR.10 ADJUST-ARRAY.BIT-VECTOR.11

 ADJUST-ARRAY.BIT-VECTOR.12 ADJUST-ARRAY.BIT-VECTOR.13

 ADJUST-ARRAY.BIT-VECTOR.14 ADJUST-ARRAY.BIT-VECTOR.15

 ADJUST-ARRAY.BIT-VECTOR.16 ADJUST-ARRAY.BIT-VECTOR.17

 ADJUST-ARRAY.BIT-VECTOR.18 ADJUST-ARRAY.BIT-VECTOR.19

 ADJUST-ARRAY.BIT-VECTOR.20 ADJUST-ARRAY.BIT-VECTOR.21

 ADJUST-ARRAY.BIT-VECTOR.22 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.1

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.2

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.3

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.4

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.5

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.6

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.7

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.8

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.9

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.10

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.11

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.12

 ADJUST-ARRAY.BIT-VECTOR.ADJUSTABLE.13 ADJUST-ARRAY.ERROR.1

 ADJUST-ARRAY.ERROR.2 ADJUST-ARRAY.ERROR.3 ADJUST-ARRAY.ERROR.4

 ADJUST-ARRAY.ERROR.5 ADJUST-ARRAY.ERROR.6 ADJUSTABLE-ARRAY-P.1

 ADJUSTABLE-ARRAY-P.2 ADJUSTABLE-ARRAY-P.3 ADJUSTABLE-ARRAY-P.4

 ADJUSTABLE-ARRAY-P.5 ADJUSTABLE-ARRAY-P.6 ADJUSTABLE-ARRAY-P.ORDER.1

 ADJUSTABLE-ARRAY-P.ERROR.1 ADJUSTABLE-ARRAY-P.ERROR.2

 ADJUSTABLE-ARRAY-P.ERROR.3 ADJUSTABLE-ARRAY-P.ERROR.4

 ADJUSTABLE-ARRAY-P.ERROR.5 ADJUSTABLE-ARRAY-P.ERROR.6

 ARRAY-DISPLACEMENT.7 ARRAY-DISPLACEMENT.8 ARRAY-DISPLACEMENT.9

 ARRAY-DISPLACEMENT.10 ARRAY-DISPLACEMENT.11 ARRAY-DISPLACEMENT.12

 ARRAY-DISPLACEMENT.13 ARRAY-DISPLACEMENT.14 ARRAY-DISPLACEMENT.15

 ARRAY-DISPLACEMENT.ORDER.1 ARRAY-DISPLACEMENT.ERROR.1

 ARRAY-DISPLACEMENT.ERROR.2 ARRAY-DISPLACEMENT.ERROR.3

 ARRAY-DISPLACEMENT.ERROR.4 ARRAY-DIMENSION.1 ARRAY-DIMENSION.2

 ARRAY-DIMENSION.3 ARRAY-DIMENSION.4 ARRAY-DIMENSION.5 ARRAY-DIMENSION.6

 ARRAY-DIMENSION.7 ARRAY-DIMENSION.8 ARRAY-DIMENSION.ORDER.1

 ARRAY-DIMENSION.ERROR.1 ARRAY-DIMENSION.ERROR.2 ARRAY-DIMENSION.ERROR.3

 ARRAY-DIMENSIONS.1 ARRAY-DIMENSIONS.2 ARRAY-DIMENSIONS.3

 ARRAY-DIMENSIONS.4 ARRAY-DIMENSIONS.5 ARRAY-DIMENSIONS.6

 ARRAY-DIMENSIONS.7 ARRAY-DIMENSIONS.8 ARRAY-DIMENSIONS.ERROR.1

 ARRAY-DIMENSIONS.ERROR.2 ARRAY-DIMENSIONS.ERROR.3

 ARRAY-DIMENSIONS.ERROR.4 ARRAY-DIMENSIONS.ERROR.5 ARRAY-ELEMENT-TYPE.1

 ARRAY-ELEMENT-TYPE.ORDER.1 ARRAY-ELEMENT-TYPE.ERROR.1

 ARRAY-ELEMENT-TYPE.ERROR.2 ARRAY-ELEMENT-TYPE.ERROR.3

 ARRAY-ELEMENT-TYPE.ERROR.4 ARRAY-IN-BOUNDS-P.1 ARRAY-IN-BOUNDS-P.2

 ARRAY-IN-BOUNDS-P.3 ARRAY-IN-BOUNDS-P.4 ARRAY-IN-BOUNDS-P.5

 ARRAY-IN-BOUNDS-P.6 ARRAY-IN-BOUNDS-P.7 ARRAY-IN-BOUNDS-P.8

 ARRAY-IN-BOUNDS-P.9 ARRAY-IN-BOUNDS-P.10 ARRAY-IN-BOUNDS-P.11

 ARRAY-IN-BOUNDS-P.12 ARRAY-IN-BOUNDS-P.13 ARRAY-IN-BOUNDS-P.14

 ARRAY-IN-BOUNDS-P.15 ARRAY-IN-BOUNDS-P.16 ARRAY-IN-BOUNDS-P.17

 ARRAY-IN-BOUNDS-P.18 ARRAY-IN-BOUNDS-P.19 ARRAY-IN-BOUNDS-P.20

 ARRAY-IN-BOUNDS-P.21 ARRAY-IN-BOUNDS-P.22 ARRAY-IN-BOUNDS-P.23

 ARRAY-IN-BOUNDS-P.24 ARRAY-IN-BOUNDS-P.25 ARRAY-IN-BOUNDS-P.ORDER.1

 ARRAY-IN-BOUNDS-P.ERROR.1 ARRAY-DIMENSION-LIMIT.1

 ARRAY-DIMENSION-LIMIT.2 ARRAY-TOTAL-SIZE-LIMIT.1

 ARRAY-TOTAL-SIZE-LIMIT.2 ARRAY-RANK-LIMIT.1 ARRAY-RANK-LIMIT.2

 ARRAY-RANK.1 ARRAY-RANK.2 ARRAY-RANK.3 ARRAY-RANK.ORDER.1

 ARRAY-RANK.ERROR.1 ARRAY-RANK.ERROR.2 ARRAY-RANK.ERROR.3

 ARRAY-RANK.ERROR.4 ARRAY-RANK.ERROR.5 ARRAY-ROW-MAJOR-INDEX.1

 ARRAY-ROW-MAJOR-INDEX.2 ARRAY-ROW-MAJOR-INDEX.3 ARRAY-ROW-MAJOR-INDEX.4

 ARRAY-ROW-MAJOR-INDEX.5 ARRAY-ROW-MAJOR-INDEX.ORDER.1

 ARRAY-ROW-MAJOR-INDEX.ERROR.1 ARRAY-TOTAL-SIZE.1 ARRAY-TOTAL-SIZE.2

 ARRAY-TOTAL-SIZE.3 ARRAY-TOTAL-SIZE.4 ARRAY-TOTAL-SIZE.5

 ARRAY-TOTAL-SIZE.6 ARRAY-TOTAL-SIZE.ORDER.1 ARRAY-TOTAL-SIZE.ERROR.1

 ARRAY-TOTAL-SIZE.ERROR.2 ARRAY-TOTAL-SIZE.ERROR.3

 ARRAY-TOTAL-SIZE.ERROR.4 ARRAY-TOTAL-SIZE.ERROR.5 ARRAYP.1 ARRAYP.2

 ARRAYP.3 ARRAYP.4 ARRAYP.5 ARRAYP.6 ARRAYP.7 ARRAYP.ORDER.1

 ARRAYP.ERROR.1 ARRAYP.ERROR.2 FILL-POINTER.1 FILL-POINTER.2

 FILL-POINTER.3 FILL-POINTER.ORDER.1 FILL-POINTER.ORDER.2

 FILL-POINTER.ERROR.1 FILL-POINTER.ERROR.2 FILL-POINTER.ERROR.3

 FILL-POINTER.ERROR.4 FILL-POINTER.ERROR.5 FILL-POINTER.ERROR.6

 FILL-POINTER.ERROR.7 ROW-MAJOR-AREF.1 ROW-MAJOR-AREF.2 ROW-MAJOR-AREF.3

 ROW-MAJOR-AREF.4 ROW-MAJOR-AREF.5 ROW-MAJOR-AREF.6 ROW-MAJOR-AREF.7

 ROW-MAJOR-AREF.8 ROW-MAJOR-AREF.9 ROW-MAJOR-AREF.10

 ROW-MAJOR-AREF.ORDER.1 ROW-MAJOR-AREF.ORDER.2 ROW-MAJOR-AREF.ERROR.1

 SIMPLE-VECTOR-P.1 SIMPLE-VECTOR-P.2 SIMPLE-VECTOR-P.4 SIMPLE-VECTOR-P.7

 SIMPLE-VECTOR-P.8 SIMPLE-VECTOR-P.9 SIMPLE-VECTOR-P.10

 SIMPLE-VECTOR-P.11 SIMPLE-VECTOR-P.12 SIMPLE-VECTOR-P.ERROR.1

 SIMPLE-VECTOR-P.ERROR.2 SVREF.1 SVREF.2 SVREF.ORDER.1 SVREF.ORDER.2

 SVREF.ERROR.1 SVREF.ERROR.2 SVREF.ERROR.3 SVREF.ERROR.4

 UPGRADED-ARRAY-ELEMENT-TYPE.1 UPGRADED-ARRAY-ELEMENT-TYPE.2

 UPGRADED-ARRAY-ELEMENT-TYPE.3 UPGRADED-ARRAY-ELEMENT-TYPE.4

 UPGRADED-ARRAY-ELEMENT-TYPE.5 UPGRADED-ARRAY-ELEMENT-TYPE.6

 UPGRADED-ARRAY-ELEMENT-TYPE.7

Test UPGRADED-ARRAY-ELEMENT-TYPE.8 failed

Form: (LET ((UPGRADED-TYPES

             (MAPCAR #'UPGRADED-ARRAY-ELEMENT-TYPE

                     *UPGRADED-ARRAY-TYPES-TO-CHECK*)))

        (LOOP FOR

              TYPE1

              IN

              *UPGRADED-ARRAY-TYPES-TO-CHECK*

              FOR

              UAET1

              IN

              UPGRADED-TYPES

              APPEND

              (LOOP FOR

                    TYPE2

                    IN

                    *UPGRADED-ARRAY-TYPES-TO-CHECK*

                    FOR

                    UAET2

                    IN

                    UPGRADED-TYPES

                    WHEN

                    (AND (SUBTYPEP TYPE1 TYPE2)

                         (NOT (EMPIRICAL-SUBTYPEP UAET1 UAET2)))

                    COLLECT

                    (LIST TYPE1 TYPE2))))

Expected value: NIL

Actual value: (((EQL 2) (INTEGER -4 (4))) ((EQL 2) (INTEGER -8 (8)))

               ((EQL 2) (INTEGER -16 (16))) ((EQL 2) (INTEGER -32 (32)))

               ((EQL 2) (INTEGER -64 (64))) ((EQL 2) (INTEGER -128 (128)))

               ((EQL 4) (INTEGER -8 (8))) ((EQL 4) (INTEGER -16 (16)))

               ((EQL 4) (INTEGER -32 (32))) ((EQL 4) (INTEGER -64 (64)))

               ((EQL 4) (INTEGER -128 (128))) ((EQL 8) (INTEGER -16 (16)))

               ((EQL 8) (INTEGER -32 (32))) ((EQL 8) (INTEGER -64 (64)))

               ((EQL 8) (INTEGER -128 (128))) ((EQL 16) (INTEGER -32 (32)))

               ((EQL 16) (INTEGER -64 (64))) ((EQL 16) (INTEGER -128 (128)))

               ((EQL 32) (INTEGER -64 (64))) ((EQL 32) (INTEGER -128 (128)))

               ((EQL 64) (INTEGER -128 (128))) ((EQL 256) (INTEGER -512 (512)))

               ((EQL 256) (INTEGER -1024 (1024)))

               ((EQL 256) (INTEGER -2048 (2048)))

               ((EQL 256) (INTEGER -4096 (4096)))

               ((EQL 256) (INTEGER -8192 (8192)))

               ((EQL 256) (INTEGER -16384 (16384)))

               ((EQL 256) (INTEGER -32768 (32768)))

               ((EQL 512) (INTEGER -1024 (1024)))

               ((EQL 512) (INTEGER -2048 (2048)))

               ((EQL 512) (INTEGER -4096 (4096)))

               ((EQL 512) (INTEGER -8192 (8192)))

               ((EQL 512) (INTEGER -16384 (16384)))

               ((EQL 512) (INTEGER -32768 (32768)))

               ((EQL 1024) (INTEGER -2048 (2048)))

               ((EQL 1024) (INTEGER -4096 (4096)))

               ((EQL 1024) (INTEGER -8192 (8192)))

               ((EQL 1024) (INTEGER -16384 (16384)))

               ((EQL 1024) (INTEGER -32768 (32768)))

               ((EQL 2048) (INTEGER -4096 (4096)))

               ((EQL 2048) (INTEGER -8192 (8192)))

               ((EQL 2048) (INTEGER -16384 (16384)))

               ((EQL 2048) (INTEGER -32768 (32768)))

               ((EQL 4096) (INTEGER -8192 (8192)))

               ((EQL 4096) (INTEGER -16384 (16384)))

               ((EQL 4096) (INTEGER -32768 (32768)))

               ((EQL 8192) (INTEGER -16384 (16384)))

               ((EQL 8192) (INTEGER -32768 (32768)))

               ((EQL 16384) (INTEGER -32768 (32768)))

               ((EQL 65536) (INTEGER -131072 (131072)))

               ((EQL 65536) (INTEGER -262144 (262144)))

               ((EQL 65536) (INTEGER -524288 (524288)))

               ((EQL 65536) (INTEGER -1048576 (1048576)))

               ((EQL 65536) (INTEGER -2097152 (2097152)))

               ((EQL 65536) (INTEGER -4194304 (4194304)))

               ((EQL 65536) (INTEGER -8388608 (8388608)))

               ((EQL 65536) (INTEGER -16777216 (16777216)))

               ((EQL 65536) (INTEGER -33554432 (33554432)))

               ((EQL 65536) (INTEGER -67108864 (67108864)))

               ((EQL 65536) (INTEGER -134217728 (134217728)))

               ((EQL 65536) (INTEGER -268435456 (268435456)))

               ((EQL 65536) (INTEGER -536870912 (536870912)))

               ((EQL 65536) (INTEGER -1073741824 (1073741824)))

               ((EQL 65536) (INTEGER -2147483648 (2147483648)))

               ((EQL 65536) FIXNUM) ((EQL 131072) (INTEGER -262144 (262144)))

               ((EQL 131072) (INTEGER -524288 (524288)))

               ((EQL 131072) (INTEGER -1048576 (1048576)))

               ((EQL 131072) (INTEGER -2097152 (2097152)))

               ((EQL 131072) (INTEGER -4194304 (4194304)))

               ((EQL 131072) (INTEGER -8388608 (8388608)))

               ((EQL 131072) (INTEGER -16777216 (16777216)))

               ((EQL 131072) (INTEGER -33554432 (33554432)))

               ((EQL 131072) (INTEGER -67108864 (67108864)))

               ((EQL 131072) (INTEGER -134217728 (134217728)))

               ((EQL 131072) (INTEGER -268435456 (268435456)))

               ((EQL 131072) (INTEGER -536870912 (536870912)))

               ((EQL 131072) (INTEGER -1073741824 (1073741824)))

               ((EQL 131072) (INTEGER -2147483648 (2147483648)))

               ((EQL 131072) FIXNUM) ((EQL 262144) (INTEGER -524288 (524288)))

               ((EQL 262144) (INTEGER -1048576 (1048576)))

               ((EQL 262144) (INTEGER -2097152 (2097152)))

               ((EQL 262144) (INTEGER -4194304 (4194304)))

               ((EQL 262144) (INTEGER -8388608 (8388608)))

               ((EQL 262144) (INTEGER -16777216 (16777216)))

               ((EQL 262144) (INTEGER -33554432 (33554432)))

               ((EQL 262144) (INTEGER -67108864 (67108864)))

               ((EQL 262144) (INTEGER -134217728 (134217728)))

               ((EQL 262144) (INTEGER -268435456 (268435456)))

               ((EQL 262144) (INTEGER -536870912 (536870912)))

               ((EQL 262144) (INTEGER -1073741824 (1073741824)))

               ((EQL 262144) (INTEGER -2147483648 (2147483648)))

               ((EQL 262144) FIXNUM)

               ((EQL 524288) (INTEGER -1048576 (1048576)))

               ((EQL 524288) (INTEGER -2097152 (2097152)))

               ((EQL 524288) (INTEGER -4194304 (4194304)))

               ((EQL 524288) (INTEGER -8388608 (8388608)))

               ((EQL 524288) (INTEGER -16777216 (16777216)))

               ((EQL 524288) (INTEGER -33554432 (33554432)))

               ((EQL 524288) (INTEGER -67108864 (67108864)))

               ((EQL 524288) (INTEGER -134217728 (134217728)))

               ((EQL 524288) (INTEGER -268435456 (268435456)))

               ((EQL 524288) (INTEGER -536870912 (536870912)))

               ((EQL 524288) (INTEGER -1073741824 (1073741824)))

               ((EQL 524288) (INTEGER -2147483648 (2147483648)))

               ((EQL 524288) FIXNUM)

               ((EQL 1048576) (INTEGER -2097152 (2097152)))

               ((EQL 1048576) (INTEGER -4194304 (4194304)))

               ((EQL 1048576) (INTEGER -8388608 (8388608)))

               ((EQL 1048576) (INTEGER -16777216 (16777216)))

               ((EQL 1048576) (INTEGER -33554432 (33554432)))

               ((EQL 1048576) (INTEGER -67108864 (67108864)))

               ((EQL 1048576) (INTEGER -134217728 (134217728)))

               ((EQL 1048576) (INTEGER -268435456 (268435456)))

               ((EQL 1048576) (INTEGER -536870912 (536870912)))

               ((EQL 1048576) (INTEGER -1073741824 (1073741824)))

               ((EQL 1048576) (INTEGER -2147483648 (2147483648)))

               ((EQL 1048576) FIXNUM)

               ((EQL 2097152) (INTEGER -4194304 (4194304)))

               ((EQL 2097152) (INTEGER -8388608 (8388608)))

               ((EQL 2097152) (INTEGER -16777216 (16777216)))

               ((EQL 2097152) (INTEGER -33554432 (33554432)))

               ((EQL 2097152) (INTEGER -67108864 (67108864)))

               ((EQL 2097152) (INTEGER -134217728 (134217728)))

               ((EQL 2097152) (INTEGER -268435456 (268435456)))

               ((EQL 2097152) (INTEGER -536870912 (536870912)))

               ((EQL 2097152) (INTEGER -1073741824 (1073741824)))

               ((EQL 2097152) (INTEGER -2147483648 (2147483648)))

               ((EQL 2097152) FIXNUM)

               ((EQL 4194304) (INTEGER -8388608 (8388608)))

               ((EQL 4194304) (INTEGER -16777216 (16777216)))

               ((EQL 4194304) (INTEGER -33554432 (33554432)))

               ((EQL 4194304) (INTEGER -67108864 (67108864)))

               ((EQL 4194304) (INTEGER -134217728 (134217728)))

               ((EQL 4194304) (INTEGER -268435456 (268435456)))

               ((EQL 4194304) (INTEGER -536870912 (536870912)))

               ((EQL 4194304) (INTEGER -1073741824 (1073741824)))

               ((EQL 4194304) (INTEGER -2147483648 (2147483648)))

               ((EQL 4194304) FIXNUM)

               ((EQL 8388608) (INTEGER -16777216 (16777216)))

               ((EQL 8388608) (INTEGER -33554432 (33554432)))

               ((EQL 8388608) (INTEGER -67108864 (67108864)))

               ((EQL 8388608) (INTEGER -134217728 (134217728)))

               ((EQL 8388608) (INTEGER -268435456 (268435456)))

               ((EQL 8388608) (INTEGER -536870912 (536870912)))

               ((EQL 8388608) (INTEGER -1073741824 (1073741824)))

               ((EQL 8388608) (INTEGER -2147483648 (2147483648)))

               ((EQL 8388608) FIXNUM)

               ((EQL 16777216) (INTEGER -33554432 (33554432)))

               ((EQL 16777216) (INTEGER -67108864 (67108864)))

               ((EQL 16777216) (INTEGER -134217728 (134217728)))

               ((EQL 16777216) (INTEGER -268435456 (268435456)))

               ((EQL 16777216) (INTEGER -536870912 (536870912)))

               ((EQL 16777216) (INTEGER -1073741824 (1073741824)))

               ((EQL 16777216) (INTEGER -2147483648 (2147483648)))

               ((EQL 16777216) FIXNUM)

               ((EQL 33554432) (INTEGER -67108864 (67108864)))

               ((EQL 33554432) (INTEGER -134217728 (134217728)))

               ((EQL 33554432) (INTEGER -268435456 (268435456)))

               ((EQL 33554432) (INTEGER -536870912 (536870912)))

               ((EQL 33554432) (INTEGER -1073741824 (1073741824)))

               ((EQL 33554432) (INTEGER -2147483648 (2147483648)))

               ((EQL 33554432) FIXNUM)

               ((EQL 67108864) (INTEGER -134217728 (134217728)))

               ((EQL 67108864) (INTEGER -268435456 (268435456)))

               ((EQL 67108864) (INTEGER -536870912 (536870912)))

               ((EQL 67108864) (INTEGER -1073741824 (1073741824)))

               ((EQL 67108864) (INTEGER -2147483648 (2147483648)))

               ((EQL 67108864) FIXNUM)

               ((EQL 134217728) (INTEGER -268435456 (268435456)))

               ((EQL 134217728) (INTEGER -536870912 (536870912)))

               ((EQL 134217728) (INTEGER -1073741824 (1073741824)))

               ((EQL 134217728) (INTEGER -2147483648 (2147483648)))

               ((EQL 134217728) FIXNUM)

               ((EQL 268435456) (INTEGER -536870912 (536870912)))

               ((EQL 268435456) (INTEGER -1073741824 (1073741824)))

               ((EQL 268435456) (INTEGER -2147483648 (2147483648)))

               ((EQL 268435456) FIXNUM)

               ((EQL 536870912) (INTEGER -1073741824 (1073741824)))

               ((EQL 536870912) (INTEGER -2147483648 (2147483648)))

               ((EQL 1073741824) (INTEGER -2147483648 (2147483648)))

               ((EQL 3) (INTEGER -4 (4))) ((EQL 3) (INTEGER -8 (8)))

               ((EQL 3) (INTEGER -16 (16))) ((EQL 3) (INTEGER -32 (32)))

               ((EQL 3) (INTEGER -64 (64))) ((EQL 3) (INTEGER -128 (128)))

               ((EQL 7) (INTEGER -8 (8))) ((EQL 7) (INTEGER -16 (16)))

               ((EQL 7) (INTEGER -32 (32))) ((EQL 7) (INTEGER -64 (64)))

               ((EQL 7) (INTEGER -128 (128))) ((EQL 15) (INTEGER -16 (16)))

               ((EQL 15) (INTEGER -32 (32))) ((EQL 15) (INTEGER -64 (64)))

               ((EQL 15) (INTEGER -128 (128))) ((EQL 31) (INTEGER -32 (32)))

               ((EQL 31) (INTEGER -64 (64))) ((EQL 31) (INTEGER -128 (128)))

               ((EQL 63) (INTEGER -64 (64))) ((EQL 63) (INTEGER -128 (128)))

               ((EQL 127) (INTEGER -128 (128)))

               ((EQL 511) (INTEGER -512 (512)))

               ((EQL 511) (INTEGER -1024 (1024)))

               ((EQL 511) (INTEGER -2048 (2048)))

               ((EQL 511) (INTEGER -4096 (4096)))

               ((EQL 511) (INTEGER -8192 (8192)))

               ((EQL 511) (INTEGER -16384 (16384)))

               ((EQL 511) (INTEGER -32768 (32768)))

               ((EQL 1023) (INTEGER -1024 (1024)))

               ((EQL 1023) (INTEGER -2048 (2048)))

               ((EQL 1023) (INTEGER -4096 (4096)))

               ((EQL 1023) (INTEGER -8192 (8192)))

               ((EQL 1023) (INTEGER -16384 (16384)))

               ((EQL 1023) (INTEGER -32768 (32768)))

               ((EQL 2047) (INTEGER -2048 (2048)))

               ((EQL 2047) (INTEGER -4096 (4096)))

               ((EQL 2047) (INTEGER -8192 (8192)))

               ((EQL 2047) (INTEGER -16384 (16384)))

               ((EQL 2047) (INTEGER -32768 (32768)))

               ((EQL 4095) (INTEGER -4096 (4096)))

               ((EQL 4095) (INTEGER -8192 (8192)))

               ((EQL 4095) (INTEGER -16384 (16384)))

               ((EQL 4095) (INTEGER -32768 (32768)))

               ((EQL 8191) (INTEGER -8192 (8192)))

               ((EQL 8191) (INTEGER -16384 (16384)))

               ((EQL 8191) (INTEGER -32768 (32768)))

               ((EQL 16383) (INTEGER -16384 (16384)))

               ((EQL 16383) (INTEGER -32768 (32768)))

               ((EQL 32767) (INTEGER -32768 (32768)))

               ((EQL 131071) (INTEGER -131072 (131072)))

               ((EQL 131071) (INTEGER -262144 (262144)))

               ((EQL 131071) (INTEGER -524288 (524288)))

               ((EQL 131071) (INTEGER -1048576 (1048576)))

               ((EQL 131071) (INTEGER -2097152 (2097152)))

               ((EQL 131071) (INTEGER -4194304 (4194304)))

               ((EQL 131071) (INTEGER -8388608 (8388608)))

               ((EQL 131071) (INTEGER -16777216 (16777216)))

               ((EQL 131071) (INTEGER -33554432 (33554432)))

               ((EQL 131071) (INTEGER -67108864 (67108864)))

               ((EQL 131071) (INTEGER -134217728 (134217728)))

               ((EQL 131071) (INTEGER -268435456 (268435456)))

               ((EQL 131071) (INTEGER -536870912 (536870912)))

               ((EQL 131071) (INTEGER -1073741824 (1073741824)))

               ((EQL 131071) (INTEGER -2147483648 (2147483648)))

               ((EQL 131071) FIXNUM) ((EQL 262143) (INTEGER -262144 (262144)))

               ((EQL 262143) (INTEGER -524288 (524288)))

               ((EQL 262143) (INTEGER -1048576 (1048576)))

               ((EQL 262143) (INTEGER -2097152 (2097152)))

               ((EQL 262143) (INTEGER -4194304 (4194304)))

               ((EQL 262143) (INTEGER -8388608 (8388608)))

               ((EQL 262143) (INTEGER -16777216 (16777216)))

               ((EQL 262143) (INTEGER -33554432 (33554432)))

               ((EQL 262143) (INTEGER -67108864 (67108864)))

               ((EQL 262143) (INTEGER -134217728 (134217728)))

               ((EQL 262143) (INTEGER -268435456 (268435456)))

               ((EQL 262143) (INTEGER -536870912 (536870912)))

               ((EQL 262143) (INTEGER -1073741824 (1073741824)))

               ((EQL 262143) (INTEGER -2147483648 (2147483648)))

               ((EQL 262143) FIXNUM) ((EQL 524287) (INTEGER -524288 (524288)))

               ((EQL 524287) (INTEGER -1048576 (1048576)))

               ((EQL 524287) (INTEGER -2097152 (2097152)))

               ((EQL 524287) (INTEGER -4194304 (4194304)))

               ((EQL 524287) (INTEGER -8388608 (8388608)))

               ((EQL 524287) (INTEGER -16777216 (16777216)))

               ((EQL 524287) (INTEGER -33554432 (33554432)))

               ((EQL 524287) (INTEGER -67108864 (67108864)))

               ((EQL 524287) (INTEGER -134217728 (134217728)))

               ((EQL 524287) (INTEGER -268435456 (268435456)))

               ((EQL 524287) (INTEGER -536870912 (536870912)))

               ((EQL 524287) (INTEGER -1073741824 (1073741824)))

               ((EQL 524287) (INTEGER -2147483648 (2147483648)))

               ((EQL 524287) FIXNUM)

               ((EQL 1048575) (INTEGER -1048576 (1048576)))

               ((EQL 1048575) (INTEGER -2097152 (2097152)))

               ((EQL 1048575) (INTEGER -4194304 (4194304)))

               ((EQL 1048575) (INTEGER -8388608 (8388608)))

               ((EQL 1048575) (INTEGER -16777216 (16777216)))

               ((EQL 1048575) (INTEGER -33554432 (33554432)))

               ((EQL 1048575) (INTEGER -67108864 (67108864)))

               ((EQL 1048575) (INTEGER -134217728 (134217728)))

               ((EQL 1048575) (INTEGER -268435456 (268435456)))

               ((EQL 1048575) (INTEGER -536870912 (536870912)))

               ((EQL 1048575) (INTEGER -1073741824 (1073741824)))

               ((EQL 1048575) (INTEGER -2147483648 (2147483648)))

               ((EQL 1048575) FIXNUM)

               ((EQL 2097151) (INTEGER -2097152 (2097152)))

               ((EQL 2097151) (INTEGER -4194304 (4194304)))

               ((EQL 2097151) (INTEGER -8388608 (8388608)))

               ((EQL 2097151) (INTEGER -16777216 (16777216)))

               ((EQL 2097151) (INTEGER -33554432 (33554432)))

               ((EQL 2097151) (INTEGER -67108864 (67108864)))

               ((EQL 2097151) (INTEGER -134217728 (134217728)))

               ((EQL 2097151) (INTEGER -268435456 (268435456)))

               ((EQL 2097151) (INTEGER -536870912 (536870912)))

               ((EQL 2097151) (INTEGER -1073741824 (1073741824)))

               ((EQL 2097151) (INTEGER -2147483648 (2147483648)))

               ((EQL 2097151) FIXNUM)

               ((EQL 4194303) (INTEGER -4194304 (4194304)))

               ((EQL 4194303) (INTEGER -8388608 (8388608)))

               ((EQL 4194303) (INTEGER -16777216 (16777216)))

               ((EQL 4194303) (INTEGER -33554432 (33554432)))

               ((EQL 4194303) (INTEGER -67108864 (67108864)))

               ((EQL 4194303) (INTEGER -134217728 (134217728)))

               ((EQL 4194303) (INTEGER -268435456 (268435456)))

               ((EQL 4194303) (INTEGER -536870912 (536870912)))

               ((EQL 4194303) (INTEGER -1073741824 (1073741824)))

               ((EQL 4194303) (INTEGER -2147483648 (2147483648)))

               ((EQL 4194303) FIXNUM)

               ((EQL 8388607) (INTEGER -8388608 (8388608)))

               ((EQL 8388607) (INTEGER -16777216 (16777216)))

               ((EQL 8388607) (INTEGER -33554432 (33554432)))

               ((EQL 8388607) (INTEGER -67108864 (67108864)))

               ((EQL 8388607) (INTEGER -134217728 (134217728)))

               ((EQL 8388607) (INTEGER -268435456 (268435456)))

               ((EQL 8388607) (INTEGER -536870912 (536870912)))

               ((EQL 8388607) (INTEGER -1073741824 (1073741824)))

               ((EQL 8388607) (INTEGER -2147483648 (2147483648)))

               ((EQL 8388607) FIXNUM)

               ((EQL 16777215) (INTEGER -16777216 (16777216)))

               ((EQL 16777215) (INTEGER -33554432 (33554432)))

               ((EQL 16777215) (INTEGER -67108864 (67108864)))

               ((EQL 16777215) (INTEGER -134217728 (134217728)))

               ((EQL 16777215) (INTEGER -268435456 (268435456)))

               ((EQL 16777215) (INTEGER -536870912 (536870912)))

               ((EQL 16777215) (INTEGER -1073741824 (1073741824)))

               ((EQL 16777215) (INTEGER -2147483648 (2147483648)))

               ((EQL 16777215) FIXNUM)

               ((EQL 33554431) (INTEGER -33554432 (33554432)))

               ((EQL 33554431) (INTEGER -67108864 (67108864)))

               ((EQL 33554431) (INTEGER -134217728 (134217728)))

               ((EQL 33554431) (INTEGER -268435456 (268435456)))

               ((EQL 33554431) (INTEGER -536870912 (536870912)))

               ((EQL 33554431) (INTEGER -1073741824 (1073741824)))

               ((EQL 33554431) (INTEGER -2147483648 (2147483648)))

               ((EQL 33554431) FIXNUM)

               ((EQL 67108863) (INTEGER -67108864 (67108864)))

               ((EQL 67108863) (INTEGER -134217728 (134217728)))

               ((EQL 67108863) (INTEGER -268435456 (268435456)))

               ((EQL 67108863) (INTEGER -536870912 (536870912)))

               ((EQL 67108863) (INTEGER -1073741824 (1073741824)))

               ((EQL 67108863) (INTEGER -2147483648 (2147483648)))

               ((EQL 67108863) FIXNUM)

               ((EQL 134217727) (INTEGER -134217728 (134217728)))

               ((EQL 134217727) (INTEGER -268435456 (268435456)))

               ((EQL 134217727) (INTEGER -536870912 (536870912)))

               ((EQL 134217727) (INTEGER -1073741824 (1073741824)))

               ((EQL 134217727) (INTEGER -2147483648 (2147483648)))

               ((EQL 134217727) FIXNUM)

               ((EQL 268435455) (INTEGER -268435456 (268435456)))

               ((EQL 268435455) (INTEGER -536870912 (536870912)))

               ((EQL 268435455) (INTEGER -1073741824 (1073741824)))

               ((EQL 268435455) (INTEGER -2147483648 (2147483648)))

               ((EQL 268435455) FIXNUM)

               ((EQL 536870911) (INTEGER -536870912 (536870912)))

               ((EQL 536870911) (INTEGER -1073741824 (1073741824)))

               ((EQL 536870911) (INTEGER -2147483648 (2147483648)))

               ((EQL 536870911) FIXNUM)

               ((EQL 1073741823) (INTEGER -1073741824 (1073741824)))

               ((EQL 1073741823) (INTEGER -2147483648 (2147483648)))

               ((EQL 2147483647) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (4)) (INTEGER -4 (4)))

               ((INTEGER 0 (4)) (INTEGER -8 (8)))

               ((INTEGER 0 (4)) (INTEGER -16 (16)))

               ((INTEGER 0 (4)) (INTEGER -32 (32)))

               ((INTEGER 0 (4)) (INTEGER -64 (64)))

               ((INTEGER 0 (4)) (INTEGER -128 (128)))

               ((INTEGER 0 (8)) (INTEGER -8 (8)))

               ((INTEGER 0 (8)) (INTEGER -16 (16)))

               ((INTEGER 0 (8)) (INTEGER -32 (32)))

               ((INTEGER 0 (8)) (INTEGER -64 (64)))

               ((INTEGER 0 (8)) (INTEGER -128 (128)))

               ((INTEGER 0 (16)) (INTEGER -16 (16)))

               ((INTEGER 0 (16)) (INTEGER -32 (32)))

               ((INTEGER 0 (16)) (INTEGER -64 (64)))

               ((INTEGER 0 (16)) (INTEGER -128 (128)))

               ((INTEGER 0 (32)) (INTEGER -32 (32)))

               ((INTEGER 0 (32)) (INTEGER -64 (64)))

               ((INTEGER 0 (32)) (INTEGER -128 (128)))

               ((INTEGER 0 (64)) (INTEGER -64 (64)))

               ((INTEGER 0 (64)) (INTEGER -128 (128)))

               ((INTEGER 0 (128)) (INTEGER -128 (128)))

               ((INTEGER 0 (512)) (INTEGER -512 (512)))

               ((INTEGER 0 (512)) (INTEGER -1024 (1024)))

               ((INTEGER 0 (512)) (INTEGER -2048 (2048)))

               ((INTEGER 0 (512)) (INTEGER -4096 (4096)))

               ((INTEGER 0 (512)) (INTEGER -8192 (8192)))

               ((INTEGER 0 (512)) (INTEGER -16384 (16384)))

               ((INTEGER 0 (512)) (INTEGER -32768 (32768)))

               ((INTEGER 0 (1024)) (INTEGER -1024 (1024)))

               ((INTEGER 0 (1024)) (INTEGER -2048 (2048)))

               ((INTEGER 0 (1024)) (INTEGER -4096 (4096)))

               ((INTEGER 0 (1024)) (INTEGER -8192 (8192)))

               ((INTEGER 0 (1024)) (INTEGER -16384 (16384)))

               ((INTEGER 0 (1024)) (INTEGER -32768 (32768)))

               ((INTEGER 0 (2048)) (INTEGER -2048 (2048)))

               ((INTEGER 0 (2048)) (INTEGER -4096 (4096)))

               ((INTEGER 0 (2048)) (INTEGER -8192 (8192)))

               ((INTEGER 0 (2048)) (INTEGER -16384 (16384)))

               ((INTEGER 0 (2048)) (INTEGER -32768 (32768)))

               ((INTEGER 0 (4096)) (INTEGER -4096 (4096)))

               ((INTEGER 0 (4096)) (INTEGER -8192 (8192)))

               ((INTEGER 0 (4096)) (INTEGER -16384 (16384)))

               ((INTEGER 0 (4096)) (INTEGER -32768 (32768)))

               ((INTEGER 0 (8192)) (INTEGER -8192 (8192)))

               ((INTEGER 0 (8192)) (INTEGER -16384 (16384)))

               ((INTEGER 0 (8192)) (INTEGER -32768 (32768)))

               ((INTEGER 0 (16384)) (INTEGER -16384 (16384)))

               ((INTEGER 0 (16384)) (INTEGER -32768 (32768)))

               ((INTEGER 0 (32768)) (INTEGER -32768 (32768)))

               ((INTEGER 0 (131072)) (INTEGER -131072 (131072)))

               ((INTEGER 0 (131072)) (INTEGER -262144 (262144)))

               ((INTEGER 0 (131072)) (INTEGER -524288 (524288)))

               ((INTEGER 0 (131072)) (INTEGER -1048576 (1048576)))

               ((INTEGER 0 (131072)) (INTEGER -2097152 (2097152)))

               ((INTEGER 0 (131072)) (INTEGER -4194304 (4194304)))

               ((INTEGER 0 (131072)) (INTEGER -8388608 (8388608)))

               ((INTEGER 0 (131072)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (131072)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (131072)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (131072)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (131072)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (131072)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (131072)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (131072)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (131072)) FIXNUM)

               ((INTEGER 0 (262144)) (INTEGER -262144 (262144)))

               ((INTEGER 0 (262144)) (INTEGER -524288 (524288)))

               ((INTEGER 0 (262144)) (INTEGER -1048576 (1048576)))

               ((INTEGER 0 (262144)) (INTEGER -2097152 (2097152)))

               ((INTEGER 0 (262144)) (INTEGER -4194304 (4194304)))

               ((INTEGER 0 (262144)) (INTEGER -8388608 (8388608)))

               ((INTEGER 0 (262144)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (262144)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (262144)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (262144)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (262144)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (262144)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (262144)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (262144)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (262144)) FIXNUM)

               ((INTEGER 0 (524288)) (INTEGER -524288 (524288)))

               ((INTEGER 0 (524288)) (INTEGER -1048576 (1048576)))

               ((INTEGER 0 (524288)) (INTEGER -2097152 (2097152)))

               ((INTEGER 0 (524288)) (INTEGER -4194304 (4194304)))

               ((INTEGER 0 (524288)) (INTEGER -8388608 (8388608)))

               ((INTEGER 0 (524288)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (524288)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (524288)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (524288)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (524288)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (524288)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (524288)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (524288)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (524288)) FIXNUM)

               ((INTEGER 0 (1048576)) (INTEGER -1048576 (1048576)))

               ((INTEGER 0 (1048576)) (INTEGER -2097152 (2097152)))

               ((INTEGER 0 (1048576)) (INTEGER -4194304 (4194304)))

               ((INTEGER 0 (1048576)) (INTEGER -8388608 (8388608)))

               ((INTEGER 0 (1048576)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (1048576)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (1048576)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (1048576)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (1048576)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (1048576)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (1048576)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (1048576)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (1048576)) FIXNUM)

               ((INTEGER 0 (2097152)) (INTEGER -2097152 (2097152)))

               ((INTEGER 0 (2097152)) (INTEGER -4194304 (4194304)))

               ((INTEGER 0 (2097152)) (INTEGER -8388608 (8388608)))

               ((INTEGER 0 (2097152)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (2097152)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (2097152)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (2097152)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (2097152)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (2097152)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (2097152)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (2097152)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (2097152)) FIXNUM)

               ((INTEGER 0 (4194304)) (INTEGER -4194304 (4194304)))

               ((INTEGER 0 (4194304)) (INTEGER -8388608 (8388608)))

               ((INTEGER 0 (4194304)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (4194304)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (4194304)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (4194304)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (4194304)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (4194304)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (4194304)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (4194304)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (4194304)) FIXNUM)

               ((INTEGER 0 (8388608)) (INTEGER -8388608 (8388608)))

               ((INTEGER 0 (8388608)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (8388608)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (8388608)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (8388608)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (8388608)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (8388608)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (8388608)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (8388608)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (8388608)) FIXNUM)

               ((INTEGER 0 (16777216)) (INTEGER -16777216 (16777216)))

               ((INTEGER 0 (16777216)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (16777216)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (16777216)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (16777216)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (16777216)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (16777216)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (16777216)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (16777216)) FIXNUM)

               ((INTEGER 0 (33554432)) (INTEGER -33554432 (33554432)))

               ((INTEGER 0 (33554432)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (33554432)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (33554432)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (33554432)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (33554432)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (33554432)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (33554432)) FIXNUM)

               ((INTEGER 0 (67108864)) (INTEGER -67108864 (67108864)))

               ((INTEGER 0 (67108864)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (67108864)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (67108864)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (67108864)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (67108864)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (67108864)) FIXNUM)

               ((INTEGER 0 (134217728)) (INTEGER -134217728 (134217728)))

               ((INTEGER 0 (134217728)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (134217728)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (134217728)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (134217728)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (134217728)) FIXNUM)

               ((INTEGER 0 (268435456)) (INTEGER -268435456 (268435456)))

               ((INTEGER 0 (268435456)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (268435456)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (268435456)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (268435456)) FIXNUM)

               ((INTEGER 0 (536870912)) (INTEGER -536870912 (536870912)))

               ((INTEGER 0 (536870912)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (536870912)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (536870912)) FIXNUM)

               ((INTEGER 0 (1073741824)) (INTEGER -1073741824 (1073741824)))

               ((INTEGER 0 (1073741824)) (INTEGER -2147483648 (2147483648)))

               ((INTEGER 0 (2147483648)) (INTEGER -2147483648 (2147483648)))).

 UPGRADED-ARRAY-ELEMENT-TYPE.NIL.1 UPGRADED-ARRAY-ELEMENT-TYPE.ERROR.1

 UPGRADED-ARRAY-ELEMENT-TYPE.ERROR.2 VECTOR.TYPE.1 VECTOR.TYPE.2

 VECTOR.TYPE.3 VECTOR.TYPE.4 VECTOR.TYPE.5 VECTOR.TYPE.6 VECTOR.TYPE.7

 VECTOR.TYPE.8 VECTOR.TYPE.9 VECTOR.TYPE.10 VECTOR.TYPE.11

 VECTOR.TYPE.12 VECTOR.TYPE.13 VECTOR.TYPE.14 VECTOR.TYPE.15

 VECTOR.TYPE.16 VECTOR.TYPE.17 VECTOR.TYPE.18 VECTOR.TYPE.19

 VECTOR.TYPE.20 VECTOR.TYPE.21 VECTOR.TYPE.23 VECTOR.TYPE.23A

 VECTOR.TYPE.24 VECTOR.TYPE.25 VECTOR.TYPE.26 VECTOR.TYPE.27

 VECTOR.TYPE.28 VECTOR.TYPE.29 VECTOR.TYPE.30 VECTOR.TYPE.31

 VECTOR.TYPE.32 VECTOR.TYPE.33 VECTOR.TYPE.34 VECTOR.TYPE.35

 VECTOR.TYPE.36 VECTOR.TYPE.37 VECTOR.TYPE.38 VECTOR.TYPE.39

 VECTOR.TYPE.40 VECTOR.TYPE.41 VECTOR.TYPE.42 VECTOR.TYPE.43

 VECTOR.TYPE.44 VECTOR-AS-CLASS.1 VECTOR-AS-CLASS.2 VECTOR-AS-CLASS.3

 VECTOR-AS-CLASS.4 VECTOR-AS-CLASS.5 VECTOR-AS-CLASS.6 VECTOR-AS-CLASS.7

 VECTOR-AS-CLASS.8 VECTOR-AS-CLASS.9 VECTOR-AS-CLASS.10

 VECTOR-AS-CLASS.11 VECTOR-AS-CLASS.12 VECTOR-AS-CLASS.13

 VECTOR-AS-CLASS.14 VECTOR-AS-CLASS.15 VECTOR-AS-CLASS.16

 VECTOR-AS-CLASS.17 VECTOR-AS-CLASS.18 VECTOR.1 VECTOR.2 VECTOR.3

 VECTOR.4 VECTOR.5 VECTOR.6 VECTOR.7 VECTOR.8 VECTOR.9 VECTOR.10

 VECTOR.ORDER.1 VECTOR-POP.1 VECTOR-POP.ERROR.1 VECTOR-POP.ERROR.2

 VECTOR-POP.ERROR.3 VECTOR-POP.ERROR.4 VECTOR-PUSH.1 VECTOR-PUSH.2

 VECTOR-PUSH.3 VECTOR-PUSH.4 VECTOR-PUSH.5 VECTOR-PUSH.6 VECTOR-PUSH.7

 VECTOR-PUSH.8 VECTOR-PUSH.9 VECTOR-PUSH.10 VECTOR-PUSH.11

 VECTOR-PUSH.12 VECTOR-PUSH.13 VECTOR-PUSH.14 VECTOR-PUSH.15

 VECTOR-PUSH.16 VECTOR-PUSH.17 VECTOR-PUSH.18 VECTOR-PUSH.19

 VECTOR-PUSH.20 VECTOR-PUSH.ERROR.1 VECTOR-PUSH.ERROR.2

 VECTOR-PUSH.ERROR.3 VECTOR-PUSH.ERROR.4 VECTOR-PUSH.ERROR.5

 VECTOR-PUSH.ERROR.6 VECTOR-PUSH.ERROR.7 VECTOR-PUSH.ERROR.8

 VECTOR-PUSH.ERROR.9 VECTOR-PUSH.ERROR.10 VECTOR-PUSH.ERROR.11

 VECTOR-PUSH.ERROR.12 VECTOR-PUSH.ERROR.13 VECTOR-PUSH.ERROR.14

 VECTOR-PUSH.ERROR.15 VECTOR-PUSH.ERROR.16 VECTOR-PUSH-EXTEND.1

 VECTOR-PUSH-EXTEND.2 VECTOR-PUSH-EXTEND.3 VECTOR-PUSH-EXTEND.4

 VECTOR-PUSH-EXTEND.5 VECTOR-PUSH-EXTEND.6 VECTOR-PUSH-EXTEND.7

 VECTOR-PUSH-EXTEND.8 VECTOR-PUSH-EXTEND.9 VECTOR-PUSH-EXTEND.10

 VECTOR-PUSH-EXTEND.11 VECTOR-PUSH-EXTEND.12 VECTOR-PUSH-EXTEND.13

 VECTOR-PUSH-EXTEND.14 VECTOR-PUSH-EXTEND.15 VECTOR-PUSH-EXTEND.16

 VECTOR-PUSH-EXTEND.17 VECTOR-PUSH-EXTEND.18 VECTOR-PUSH-EXTEND.19

 VECTOR-PUSH-EXTEND.20 VECTOR-PUSH-EXTEND.21 VECTOR-PUSH-EXTEND.22

 VECTOR-PUSH-EXTEND.23 VECTOR-PUSH-EXTEND.24 VECTOR-PUSH-EXTEND.25

 VECTOR-PUSH-EXTEND.26 VECTOR-PUSH-EXTEND.27 VECTOR-PUSH-EXTEND.28

 VECTOR-PUSH-EXTEND.29 VECTOR-PUSH-EXTEND.30 VECTOR-PUSH-EXTEND.ERROR.1

 VECTOR-PUSH-EXTEND.ERROR.2 VECTOR-PUSH-EXTEND.ERROR.3

 VECTOR-PUSH-EXTEND.ERROR.4 VECTOR-PUSH-EXTEND.ERROR.5

 VECTOR-PUSH-EXTEND.ERROR.6 VECTOR-PUSH-EXTEND.ERROR.7

 VECTOR-PUSH-EXTEND.ERROR.8 VECTOR-PUSH-EXTEND.ERROR.9

 VECTOR-PUSH-EXTEND.ERROR.10 VECTOR-PUSH-EXTEND.ERROR.11

 VECTOR-PUSH-EXTEND.ERROR.12 VECTOR-PUSH-EXTEND.ERROR.13

 VECTOR-PUSH-EXTEND.ERROR.14 VECTOR-PUSH-EXTEND.ERROR.15

 VECTOR-PUSH-EXTEND.ERROR.16 VECTOR-PUSH-EXTEND.ERROR.17 VECTORP.1

 VECTORP.2 VECTORP.3 VECTORP.4 VECTORP.5 VECTORP.6 VECTORP.7 VECTORP.8

 VECTORP.9 VECTORP.10 VECTORP.11 VECTORP.12 VECTORP.13 VECTORP.14

 VECTORP.15 VECTORP.ERROR.1 VECTORP.ERROR.2 BIT.1 BIT.2 BIT.3 BIT.4

 BIT.5 BIT.6 BIT.7 BIT.8 BIT.ORDER.1 BIT.ORDER.2 BIT.ERROR.1 SBIT.1

 SBIT.2 SBIT.3 SBIT.4 SBIT.5 SBIT.6 SBIT.ORDER.1 SBIT.ORDER.2

 SBIT.ERROR.1 BIT-AND.1 BIT-AND.2 BIT-AND.3 BIT-AND.4 BIT-AND.5

 BIT-AND.6 BIT-AND.7 BIT-AND.8 BIT-AND.9 BIT-AND.10 BIT-AND.11

 BIT-AND.12 BIT-AND.13 BIT-AND.14 BIT-AND.15 BIT-AND.16 BIT-AND.17

 BIT-AND.18 BIT-AND.19 BIT-AND.20 BIT-AND.21 BIT-AND.22 BIT-AND.ORDER.1

 BIT-AND.FOLD.1 BIT-AND.RANDOM.1 BIT-AND.ERROR.1 BIT-AND.ERROR.2

 BIT-AND.ERROR.3 BIT-ANDC1.1 BIT-ANDC1.2 BIT-ANDC1.3 BIT-ANDC1.4

 BIT-ANDC1.5 BIT-ANDC1.6 BIT-ANDC1.7 BIT-ANDC1.8 BIT-ANDC1.9

 BIT-ANDC1.10 BIT-ANDC1.11 BIT-ANDC1.12 BIT-ANDC1.13 BIT-ANDC1.14

 BIT-ANDC1.15 BIT-ANDC1.16 BIT-ANDC1.17 BIT-ANDC1.18 BIT-ANDC1.19

 BIT-ANDC1.20 BIT-ANDC1.21 BIT-ANDC1.22 BIT-ANDC1.ORDER.1

 BIT-ANDC1.FOLD.1 BIT-ANDC1.RANDOM.1 BIT-ANDC1.ERROR.1 BIT-ANDC1.ERROR.2

 BIT-ANDC1.ERROR.3 BIT-ANDC2.1 BIT-ANDC2.2 BIT-ANDC2.3 BIT-ANDC2.4

 BIT-ANDC2.5 BIT-ANDC2.6 BIT-ANDC2.7 BIT-ANDC2.8 BIT-ANDC2.9

 BIT-ANDC2.10 BIT-ANDC2.11 BIT-ANDC2.12 BIT-ANDC2.13 BIT-ANDC2.14

 BIT-ANDC2.15 BIT-ANDC2.16 BIT-ANDC2.17 BIT-ANDC2.18 BIT-ANDC2.19

 BIT-ANDC2.20 BIT-ANDC2.21 BIT-ANDC2.22 BIT-ANDC2.ORDER.1

 BIT-ANDC2.FOLD.1 BIT-ANDC2.RANDOM.1 BIT-ANDC2.ERROR.1 BIT-ANDC2.ERROR.2

 BIT-ANDC2.ERROR.3 BIT-EQV.1 BIT-EQV.2 BIT-EQV.3 BIT-EQV.4 BIT-EQV.5

 BIT-EQV.6 BIT-EQV.7 BIT-EQV.8 BIT-EQV.9 BIT-EQV.10 BIT-EQV.11

 BIT-EQV.12 BIT-EQV.13 BIT-EQV.14 BIT-EQV.15 BIT-EQV.16 BIT-EQV.17

 BIT-EQV.18 BIT-EQV.19 BIT-EQV.20 BIT-EQV.21 BIT-EQV.22 BIT-EQV.ORDER.1

 BIT-EQV.FOLD.1 BIT-EQV.RANDOM.1 BIT-EQV.ERROR.1 BIT-EQV.ERROR.2

 BIT-EQV.ERROR.3 BIT-IOR.1 BIT-IOR.2 BIT-IOR.3 BIT-IOR.4 BIT-IOR.5

 BIT-IOR.6 BIT-IOR.7 BIT-IOR.8 BIT-IOR.9 BIT-IOR.10 BIT-IOR.11

 BIT-IOR.12 BIT-IOR.13 BIT-IOR.14 BIT-IOR.15 BIT-IOR.16 BIT-IOR.17

 BIT-IOR.18 BIT-IOR.19 BIT-IOR.20 BIT-IOR.21 BIT-IOR.22 BIT-IOR.ORDER.1

 BIT-IOR.FOLD.1 BIT-IOR.RANDOM.1 BIT-IOR.ERROR.1 BIT-IOR.ERROR.2

 BIT-IOR.ERROR.3 BIT-NAND.1 BIT-NAND.2 BIT-NAND.3 BIT-NAND.4 BIT-NAND.5

 BIT-NAND.6 BIT-NAND.7 BIT-NAND.8 BIT-NAND.9 BIT-NAND.10 BIT-NAND.11

 BIT-NAND.12 BIT-NAND.13 BIT-NAND.14 BIT-NAND.15 BIT-NAND.16 BIT-NAND.17

 BIT-NAND.18 BIT-NAND.19 BIT-NAND.20 BIT-NAND.21 BIT-NAND.22

 BIT-NAND.ORDER.1 BIT-NAND.FOLD.1 BIT-NAND.RANDOM.1 BIT-NAND.ERROR.1

 BIT-NAND.ERROR.2 BIT-NAND.ERROR.3 BIT-NOR.1 BIT-NOR.2 BIT-NOR.3

 BIT-NOR.4 BIT-NOR.5 BIT-NOR.6 BIT-NOR.7 BIT-NOR.8 BIT-NOR.9 BIT-NOR.10

 BIT-NOR.11 BIT-NOR.12 BIT-NOR.13 BIT-NOR.14 BIT-NOR.15 BIT-NOR.16

 BIT-NOR.17 BIT-NOR.18 BIT-NOR.19 BIT-NOR.20 BIT-NOR.21 BIT-NOR.22

 BIT-NOR.ORDER.1 BIT-NOR.FOLD.1 BIT-NOR.RANDOM.1 BIT-NOR.ERROR.1

 BIT-NOR.ERROR.2 BIT-NOR.ERROR.3 BIT-ORC1.1 BIT-ORC1.2 BIT-ORC1.3

 BIT-ORC1.4 BIT-ORC1.5 BIT-ORC1.6 BIT-ORC1.7 BIT-ORC1.8 BIT-ORC1.9

 BIT-ORC1.10 BIT-ORC1.11 BIT-ORC1.12 BIT-ORC1.13 BIT-ORC1.14 BIT-ORC1.15

 BIT-ORC1.16 BIT-ORC1.17 BIT-ORC1.18 BIT-ORC1.19 BIT-ORC1.20 BIT-ORC1.21

 BIT-ORC1.22 BIT-ORC1.ORDER.1 BIT-ORC1.FOLD.1 BIT-ORC1.RANDOM.1

 BIT-ORC1.ERROR.1 BIT-ORC1.ERROR.2 BIT-ORC1.ERROR.3 BIT-ORC2.1

 BIT-ORC2.2 BIT-ORC2.3 BIT-ORC2.4 BIT-ORC2.5 BIT-ORC2.6 BIT-ORC2.7

 BIT-ORC2.8 BIT-ORC2.9 BIT-ORC2.10 BIT-ORC2.11 BIT-ORC2.12 BIT-ORC2.13

 BIT-ORC2.14 BIT-ORC2.15 BIT-ORC2.16 BIT-ORC2.17 BIT-ORC2.18 BIT-ORC2.19

 BIT-ORC2.20 BIT-ORC2.21 BIT-ORC2.22 BIT-ORC2.ORDER.1 BIT-ORC2.FOLD.1

 BIT-ORC2.RANDOM.1 BIT-ORC2.ERROR.1 BIT-ORC2.ERROR.2 BIT-ORC2.ERROR.3

 BIT-XOR.1 BIT-XOR.2 BIT-XOR.3 BIT-XOR.4 BIT-XOR.5 BIT-XOR.6 BIT-XOR.7

 BIT-XOR.8 BIT-XOR.9 BIT-XOR.10 BIT-XOR.11 BIT-XOR.12 BIT-XOR.13

 BIT-XOR.14 BIT-XOR.15 BIT-XOR.16 BIT-XOR.17 BIT-XOR.18 BIT-XOR.19

 BIT-XOR.20 BIT-XOR.21 BIT-XOR.22 BIT-XOR.ORDER.1 BIT-XOR.FOLD.1

 BIT-XOR.RANDOM.1 BIT-XOR.ERROR.1 BIT-XOR.ERROR.2 BIT-XOR.ERROR.3

 BIT-NOT.1 BIT-NOT.2 BIT-NOT.3 BIT-NOT.4 BIT-NOT.5 BIT-NOT.6 BIT-NOT.7

 BIT-NOT.8 BIT-NOT.9 BIT-NOT.10 BIT-NOT.11 BIT-NOT.12 BIT-NOT.13

 BIT-NOT.14 BIT-NOT.15 BIT-NOT.16 BIT-NOT.17 BIT-NOT.ORDER.1

 BIT-NOT.FOLD.1 BIT-NOT.ERROR.1 BIT-NOT.ERROR.2 BIT-VECTOR-P.2

 BIT-VECTOR-P.3 BIT-VECTOR-P.4 BIT-VECTOR-P.5 BIT-VECTOR-P.6

 BIT-VECTOR-P.7 BIT-VECTOR-P.8 BIT-VECTOR-P.9 BIT-VECTOR-P.10

 BIT-VECTOR-P.11 BIT-VECTOR-P.12 BIT-VECTOR-P.13 BIT-VECTOR-P.ORDER.1

 BIT-VECTOR-P.ORDER.2 BIT-VECTOR-P.ERROR.1 BIT-VECTOR-P.ERROR.2

 SIMPLE-BIT-VECTOR-P.2 SIMPLE-BIT-VECTOR-P.3 SIMPLE-BIT-VECTOR-P.4

 SIMPLE-BIT-VECTOR-P.5 SIMPLE-BIT-VECTOR-P.6 SIMPLE-BIT-VECTOR-P.7

 SIMPLE-BIT-VECTOR-P.8 SIMPLE-BIT-VECTOR-P.9 SIMPLE-BIT-VECTOR-P.10

 SIMPLE-BIT-VECTOR-P.11 SIMPLE-BIT-VECTOR-P.12

 SIMPLE-BIT-VECTOR-P.ERROR.1 SIMPLE-BIT-VECTOR-P.ERROR.2 HASH-TABLE.1

 HASH-TABLE.2 HASH-TABLE.3 HASH-TABLE.4 HASH-TABLE.5 MAKE-HASH-TABLE.1

 MAKE-HASH-TABLE.2 MAKE-HASH-TABLE.3 MAKE-HASH-TABLE.4 MAKE-HASH-TABLE.5

 MAKE-HASH-TABLE.6 MAKE-HASH-TABLE.7 MAKE-HASH-TABLE.8 MAKE-HASH-TABLE.9

 MAKE-HASH-TABLE.10 MAKE-HASH-TABLE.11 MAKE-HASH-TABLE.12

 MAKE-HASH-TABLE.13 MAKE-HASH-TABLE.14 MAKE-HASH-TABLE.15

 MAKE-HASH-TABLE.16 MAKE-HASH-TABLE.17 MAKE-HASH-TABLE.18

 MAKE-HASH-TABLE.19 MAKE-HASH-TABLE.20 MAKE-HASH-TABLE.21

 MAKE-HASH-TABLE.22 MAKE-HASH-TABLE.23 MAKE-HASH-TABLE.24

 MAKE-HASH-TABLE.25 MAKE-HASH-TABLE.26 MAKE-HASH-TABLE.27

 MAKE-HASH-TABLE.28 MAKE-HASH-TABLE.29 HASH-TABLE-P.1 HASH-TABLE-P.2

 HASH-TABLE-P.3 HASH-TABLE-P.4 HASH-TABLE-P.5 HASH-TABLE-P.ERROR.1

 HASH-TABLE-P.ERROR.2 HASH-TABLE-COUNT.1 HASH-TABLE-COUNT.2

 HASH-TABLE-COUNT.3 HASH-TABLE-COUNT.4 HASH-TABLE-COUNT.5

 HASH-TABLE-COUNT.6 HASH-TABLE-COUNT.7 HASH-TABLE-COUNT.8

 HASH-TABLE-COUNT.9 HASH-TABLE-COUNT.10 HASH-TABLE-COUNT.11

 HASH-TABLE-COUNT.ERROR.1 HASH-TABLE-COUNT.ERROR.2

 HASH-TABLE-SIZE.ERROR.1 HASH-TABLE-SIZE.ERROR.2 HASH-TABLE-SIZE.ERROR.3

 HASH-TABLE-REHASH-SIZE.1 HASH-TABLE-REHASH-SIZE.2

 HASH-TABLE-REHASH-SIZE.3 HASH-TABLE-REHASH-SIZE.ERROR.1

 HASH-TABLE-REHASH-SIZE.ERROR.2 HASH-TABLE-REHASH-SIZE.ERROR.3

 HASH-TABLE-REHASH-THRESHOLD.1 HASH-TABLE-REHASH-THRESHOLD.2

 HASH-TABLE-REHASH-THRESHOLD.3 HASH-TABLE-REHASH-THRESHOLD.ERROR.1

 HASH-TABLE-REHASH-THRESHOLD.ERROR.2 HASH-TABLE-REHASH-THRESHOLD.ERROR.3

 HASH-TABLE-TEST.1 HASH-TABLE-TEST.2 HASH-TABLE-TEST.3 HASH-TABLE-TEST.4

 HASH-TABLE-TEST.ERROR.1 HASH-TABLE-TEST.ERROR.2 HASH-TABLE-TEST.ERROR.3

 GETHASH.1 GETHASH.2 GETHASH.3 GETHASH.4 GETHASH.5 GETHASH.ORDER.1

 GETHASH.ORDER.2 GETHASH.ORDER.3 GETHASH.ORDER.4 GETHASH.ZERO.1

 GETHASH.ZERO.2 GETHASH.ZERO.3 GETHASH.ZERO.4 GETHASH.ERROR.1

 GETHASH.ERROR.2 GETHASH.ERROR.3 REMHASH.1 REMHASH.2 REMHASH.3 REMHASH.4

 REMHASH.5 REMHASH.6 REMHASH.ORDER.1 REMHASH.ERROR.1 REMHASH.ERROR.2

 REMHASH.ERROR.3 CLRHASH.1 CLRHASH.2 CLRHASH.3 CLRHASH.4 CLRHASH.5

 CLRHASH.ERROR.1 CLRHASH.ERROR.2 MAPHASH.1 MAPHASH.2 MAPHASH.3 MAPHASH.4

 MAPHASH.5 MAPHASH.6 MAPHASH.7 MAPHASH.8 MAPHASH.ORDER.1 MAPHASH.ERROR.1

 MAPHASH.ERROR.2 MAPHASH.ERROR.3 WITH-HASH-TABLE-ITERATOR.1

 WITH-HASH-TABLE-ITERATOR.2 WITH-HASH-TABLE-ITERATOR.3

 WITH-HASH-TABLE-ITERATOR.4 WITH-HASH-TABLE-ITERATOR.5

 WITH-HASH-TABLE-ITERATOR.6 WITH-HASH-TABLE-ITERATOR.7

 WITH-HASH-TABLE-ITERATOR.8 WITH-HASH-TABLE-ITERATOR.8A

 WITH-HASH-TABLE-ITERATOR.9 WITH-HASH-TABLE-ITERATOR.10

 WITH-HASH-TABLE-ITERATOR.11 WITH-HASH-TABLE-ITERATOR.12 SXHASH.1

 SXHASH.2 SXHASH.3 SXHASH.4 SXHASH.5 SXHASH.6 SXHASH.7 SXHASH.9

 SXHASH.10 SXHASH.11 SXHASH.12 SXHASH.13 SXHASH.15 SXHASH.16 SXHASH.17

 SXHASH.18 SXHASH.19 SXHASH.20 SXHASH.21 SXHASH.22 SXHASH.23

 SXHASH.ERROR.1 SXHASH.ERROR.2 FIND-SYMBOL.1 FIND-SYMBOL.2 FIND-SYMBOL.3

 FIND-SYMBOL.4 FIND-SYMBOL.5 FIND-SYMBOL.6 FIND-SYMBOL.7 FIND-SYMBOL.8

 FIND-SYMBOL.9 FIND-SYMBOL.10 FIND-SYMBOL.11 FIND-SYMBOL.12

 FIND-SYMBOL.13 FIND-SYMBOL.14 FIND-SYMBOL.15 FIND-SYMBOL.16

 FIND-SYMBOL.17 FIND-SYMBOL.18 FIND-SYMBOL.19 FIND-SYMBOL.20

 FIND-SYMBOL.21 FIND-SYMBOL.22 FIND-SYMBOL.23 FIND-SYMBOL.ORDER.1

 FIND-SYMBOL.ERROR.1 FIND-SYMBOL.ERROR.2 FIND-ALL-SYMBOLS.1

Test FIND-ALL-SYMBOLS.2 failed

Form: (LOOP FOR

            I

            FROM

            0

            TO

            255

            FOR

            C

            =

            (CODE-CHAR I)

            WHEN

            (AND (CHARACTERP C)

                 (LOOP FOR

                       SYM

                       IN

                       (FIND-ALL-SYMBOLS C)

                       THEREIS

                       (NOT (STRING= (SYMBOL-NAME SYM) (STRING C)))))

            COLLECT

            C)

Expected value: NIL

Actual value: #<a TYPE-ERROR>.

 FIND-ALL-SYMBOLS.3 FIND-ALL-SYMBOLS.4 FIND-ALL-SYMBOLS.5

 FIND-ALL-SYMBOLS.6 FIND-ALL-SYMBOLS.7 FIND-ALL-SYMBOLS.8

 FIND-ALL-SYMBOLS.9 FIND-ALL-SYMBOLS.ERROR.1 FIND-ALL-SYMBOLS.ERROR.2

 FIND-PACKAGE.1 FIND-PACKAGE.2 FIND-PACKAGE.3 FIND-PACKAGE.4

 FIND-PACKAGE.5 FIND-PACKAGE.6 FIND-PACKAGE.7 FIND-PACKAGE.8

 FIND-PACKAGE.9 FIND-PACKAGE.10 FIND-PACKAGE.11 FIND-PACKAGE.12

 FIND-PACKAGE.13 FIND-PACKAGE.14 FIND-PACKAGE.15 FIND-PACKAGE.16

 FIND-PACKAGE.17 FIND-PACKAGE.ERROR.1 FIND-PACKAGE.ERROR.2

 LIST-ALL-PACKAGES.1 LIST-ALL-PACKAGES.2 LIST-ALL-PACKAGES.3

 LIST-ALL-PACKAGES.4 LIST-ALL-PACKAGES.ERROR.1 PACKAGE-NAME.1

 PACKAGE-NAME.2 PACKAGE-NAME.3 PACKAGE-NAME.4 PACKAGE-NAME.5

 PACKAGE-NAME.6 PACKAGE-NAME.6A PACKAGE-NAME.7 PACKAGE-NAME.8

 PACKAGE-NAME.9 PACKAGE-NAME.10 PACKAGE-NAME.11 PACKAGE-NAME.12

 PACKAGE-NAME.13 PACKAGE-NAME.14 PACKAGE-NAME.15 PACKAGE-NAME.16

 PACKAGE-NAME.17 PACKAGE-NAME.18 PACKAGE-NAME.19 PACKAGE-NAME.20

 PACKAGE-NAME.21 PACKAGE-NAME.22 PACKAGE-NAME.ERROR.1

 PACKAGE-NAME.ERROR.2 PACKAGE-NAME.ERROR.3 PACKAGE-NICKNAMES.1

 PACKAGE-NICKNAMES.2 PACKAGE-NICKNAMES.3 PACKAGE-NICKNAMES.4

 PACKAGE-NICKNAMES.5 PACKAGE-NICKNAMES.6 PACKAGE-NICKNAMES.7

 PACKAGE-NICKNAMES.8 PACKAGE-NICKNAMES.9 PACKAGE-NICKNAMES.9A

 PACKAGE-NICKNAMES.10 PACKAGE-NICKNAMES.11 PACKAGE-NICKNAMES.12

 PACKAGE-NICKNAMES.16 PACKAGE-NICKNAMES.17 PACKAGE-NICKNAMES.18

 PACKAGE-NICKNAMES.19 PACKAGE-NICKNAMES.20 PACKAGE-NICKNAMES.21

 PACKAGE-NICKNAMES.22 PACKAGE-NICKNAMES.ERROR.1

 PACKAGE-NICKNAMES.ERROR.2 PACKAGE-NICKNAMES.ERROR.3 INTERN.1 INTERN.2

 INTERN.4 INTERN.5 INTERN.6 INTERN.7 INTERN.8 INTERN.9 INTERN.10

 INTERN.11 INTERN.12 INTERN.13 INTERN.14 INTERN.15 INTERN.16 INTERN.17

 INTERN.18 INTERN.ERROR.1 INTERN.ERROR.2 EXPORT.1 EXPORT.2 EXPORT.3

 EXPORT.4Caught error in EXPORT.5: Cannot export the symbol TEST1::X

from #<"TEST1" package>,

because it will cause a name conflict

in #<"TEST2" package>.

 EXPORT.5 EXPORT.ERROR.1 EXPORT.ERROR.2 RENAME-PACKAGE.1

 RENAME-PACKAGE.2 RENAME-PACKAGE.3 RENAME-PACKAGE.4 RENAME-PACKAGE.5

 RENAME-PACKAGE.6 RENAME-PACKAGE.7 RENAME-PACKAGE.8 RENAME-PACKAGE.9

 RENAME-PACKAGE.ERROR.1 RENAME-PACKAGE.ERROR.2 RENAME-PACKAGE.ERROR.3

 SHADOW.1 SHADOW.2 SHADOW.3 SHADOW.4 SHADOW.5 SHADOW.6 SHADOW.7 SHADOW.8

 SHADOW.9 SHADOW.10 SHADOW.ERROR.1 SHADOW.ERROR.2 SHADOWING-IMPORT.1

 SHADOWING-IMPORT.2 SHADOWING-IMPORT.3 SHADOWING-IMPORT.4

 SHADOWING-IMPORT.5 SHADOWING-IMPORT.6 SHADOWING-IMPORT.7

 SHADOWING-IMPORT.8 SHADOWING-IMPORT.9 SHADOWING-IMPORT.10

 SHADOWING-IMPORT.11 SHADOWING-IMPORT.ERROR.1 SHADOWING-IMPORT.ERROR.2

 DELETE-PACKAGE.1 DELETE-PACKAGE.2 DELETE-PACKAGE.3 DELETE-PACKAGE.4

 DELETE-PACKAGE.5 DELETE-PACKAGE.6 DELETE-PACKAGE.7 DELETE-PACKAGE.8

 DELETE-PACKAGE.9 DELETE-PACKAGE.10 DELETE-PACKAGE.11 DELETE-PACKAGE.12

 DELETE-PACKAGE.13 DELETE-PACKAGE.ERROR.1 DELETE-PACKAGE.ERROR.2

 MAKE-PACKAGE.1 MAKE-PACKAGE.2 MAKE-PACKAGE.3 MAKE-PACKAGE.4

 MAKE-PACKAGE.5 MAKE-PACKAGE.6 MAKE-PACKAGE.7 MAKE-PACKAGE.7A

 MAKE-PACKAGE.7B MAKE-PACKAGE.8 MAKE-PACKAGE.8A MAKE-PACKAGE.8B

 MAKE-PACKAGE.9 MAKE-PACKAGE.9A MAKE-PACKAGE.9B MAKE-PACKAGE.10

 MAKE-PACKAGE.11 MAKE-PACKAGE.12 MAKE-PACKAGE.13 MAKE-PACKAGE.14

 MAKE-PACKAGE.15 MAKE-PACKAGE.16 MAKE-PACKAGE.17 MAKE-PACKAGE.18

 MAKE-PACKAGE.19 MAKE-PACKAGE.20 MAKE-PACKAGE.21 MAKE-PACKAGE.22

 MAKE-PACKAGE.23 MAKE-PACKAGE.24 MAKE-PACKAGE.25 MAKE-PACKAGE.26

 MAKE-PACKAGE.27 MAKE-PACKAGE.28 MAKE-PACKAGE.29 MAKE-PACKAGE.30

 MAKE-PACKAGE.31 MAKE-PACKAGE.32 MAKE-PACKAGE.33 MAKE-PACKAGE.34

 MAKE-PACKAGE.ERROR.1 MAKE-PACKAGE.ERROR.2 MAKE-PACKAGE.ERROR.3

 MAKE-PACKAGE.ERROR.4 MAKE-PACKAGE.ERROR.5 MAKE-PACKAGE.ERROR.6

 MAKE-PACKAGE.ERROR.7 MAKE-PACKAGE.ERROR.8 MAKE-PACKAGE.ERROR.9

 MAKE-PACKAGE.ERROR.10 MAKE-PACKAGE.ERROR.11 WITH-PACKAGE-ITERATOR.1

 WITH-PACKAGE-ITERATOR.2 WITH-PACKAGE-ITERATOR.3 WITH-PACKAGE-ITERATOR.4

 WITH-PACKAGE-ITERATOR.5 WITH-PACKAGE-ITERATOR.6 WITH-PACKAGE-ITERATOR.7

 WITH-PACKAGE-ITERATOR.8 WITH-PACKAGE-ITERATOR.9

 WITH-PACKAGE-ITERATOR.10 WITH-PACKAGE-ITERATOR.11Package #<"B" package>

Package #<"A" package>

Package #<"TEST-DPE2" package>

Package #<"LOOP.16.PACKAGE" package>

Package #<"LOOP.15.PACKAGE" package>

Package #<"LOAD-TEST-PACKAGE" package>

Package #<"STRUCT-TEST-PACKAGE" package>

Package #<"DS4" package>

Package #<"DS3" package>

Package #<"DS2" package>

Package #<"DS1" package>

Package #<"FS-B" package>

Package #<"FS-A" package>

Package #<"CL-TEST-MLFSS-PACKAGE" package>

Package #<"LOOP.CL-TEST.2" package>

Package #<"LOOP.CL-TEST.1" package>

Package #<"CL-TEST" package>

Package #<"REGRESSION-TEST" package>

Package #<"C" package>

Package #<"FFI" package>

Package #<"GRAY" package>

Package #<"MP" package>

Package #<"CLOS" package>

Package #<"SI" package>

Package #<"KEYWORD" package>

Package #<"COMMON-LISP-USER" package>

Package #<"COMMON-LISP" package>

 WITH-PACKAGE-ITERATOR.12Package #<"B" package>

Package #<"A" package>

Package #<"TEST-DPE2" package>

Package #<"LOOP.16.PACKAGE" package>

Package #<"LOOP.15.PACKAGE" package>

Package #<"LOAD-TEST-PACKAGE" package>

Package #<"STRUCT-TEST-PACKAGE" package>

Package #<"DS4" package>

Package #<"DS3" package>

Package #<"DS2" package>

Package #<"DS1" package>

Package #<"FS-B" package>

Package #<"FS-A" package>

Package #<"CL-TEST-MLFSS-PACKAGE" package>

Package #<"LOOP.CL-TEST.2" package>

Package #<"LOOP.CL-TEST.1" package>

Package #<"CL-TEST" package>

Package #<"REGRESSION-TEST" package>

Package #<"C" package>

Package #<"FFI" package>

Package #<"GRAY" package>

Package #<"MP" package>

Package #<"CLOS" package>

Package #<"SI" package>

Package #<"KEYWORD" package>

Package #<"COMMON-LISP-USER" package>

Package #<"COMMON-LISP" package>

 WITH-PACKAGE-ITERATOR.13Package #<"B" package>

Package #<"A" package>

Package #<"TEST-DPE2" package>

Package #<"LOOP.16.PACKAGE" package>

Package #<"LOOP.15.PACKAGE" package>

Package #<"LOAD-TEST-PACKAGE" package>

Package #<"STRUCT-TEST-PACKAGE" package>

Package #<"DS4" package>

Package #<"DS3" package>

Package #<"DS2" package>

Package #<"DS1" package>

Package #<"FS-B" package>

Package #<"FS-A" package>

Package #<"CL-TEST-MLFSS-PACKAGE" package>

Package #<"LOOP.CL-TEST.2" package>

Package #<"LOOP.CL-TEST.1" package>

Package #<"CL-TEST" package>

Package #<"REGRESSION-TEST" package>

Package #<"C" package>

Package #<"FFI" package>

Package #<"GRAY" package>

Package #<"MP" package>

Package #<"CLOS" package>

Package #<"SI" package>

Package #<"KEYWORD" package>

Package #<"COMMON-LISP-USER" package>

Package #<"COMMON-LISP" package>

 WITH-PACKAGE-ITERATOR.14 WITH-PACKAGE-ITERATOR.ERROR.1

 WITH-PACKAGE-ITERATOR.15 WITH-PACKAGE-ITERATOR.16

 WITH-PACKAGE-ITERATOR.17 WITH-PACKAGE-ITERATOR.18

 WITH-PACKAGE-ITERATOR.19 WITH-PACKAGE-ITERATOR.20

 WITH-PACKAGE-ITERATOR.21 WITH-PACKAGE-ITERATOR.22 UNEXPORT.1 UNEXPORT.2

 UNEXPORT.3 UNEXPORT.4 UNEXPORT.5 UNEXPORT.6 UNEXPORT.7 UNEXPORT.8

 UNEXPORT.9 UNEXPORT.10 UNEXPORT.11 UNEXPORT.12 UNEXPORT.13

 UNEXPORT.ERROR.1 UNEXPORT.ERROR.2 UNINTERN.1 UNINTERN.2 UNINTERN.3

 UNINTERN.4 UNINTERN.5 UNINTERN.6 UNINTERN.7Properly threw an error: #<a SIMPLE-PACKAGE-ERROR>

 UNINTERN.8 UNINTERN.9 UNINTERN.10 UNINTERN.11 UNINTERN.12 UNINTERN.13

 UNINTERN.14 UNINTERN.15 UNINTERN.16 UNINTERN.ERROR.1 UNINTERN.ERROR.2

 IN-PACKAGE.1 IN-PACKAGE.2 IN-PACKAGE.3 IN-PACKAGE.4 IN-PACKAGE.5

 IN-PACKAGE.ERROR.1 IN-PACKAGE.7 IN-PACKAGE.8 IN-PACKAGE.9 IN-PACKAGE.10

 IN-PACKAGE.11 IN-PACKAGE.12 IN-PACKAGE.13 UNUSE-PACKAGE.1

 UNUSE-PACKAGE.2 UNUSE-PACKAGE.3 UNUSE-PACKAGE.4 UNUSE-PACKAGE.5

 UNUSE-PACKAGE.6 UNUSE-PACKAGE.7 UNUSE-PACKAGE.8 UNUSE-PACKAGE.9

 UNUSE-PACKAGE.10 UNUSE-PACKAGE.11 UNUSE-PACKAGE.12 UNUSE-PACKAGE.13

 UNUSE-PACKAGE.14 UNUSE-PACKAGE.15 UNUSE-PACKAGE.16 UNUSE-PACKAGE.17

 UNUSE-PACKAGE.18 UNUSE-PACKAGE.19 UNUSE-PACKAGE.20 UNUSE-PACKAGE.21

 UNUSE-PACKAGE.22 UNUSE-PACKAGE.23 UNUSE-PACKAGE.ERROR.1

 UNUSE-PACKAGE.ERROR.2 USE-PACKAGE.1 USE-PACKAGE.2 USE-PACKAGE.3

 USE-PACKAGE.4 USE-PACKAGE.5 USE-PACKAGE.6 USE-PACKAGE.7 USE-PACKAGE.10

 USE-PACKAGE.11 USE-PACKAGE.12 USE-PACKAGE.13 USE-PACKAGE.14

 USE-PACKAGE.15 USE-PACKAGE.16 USE-PACKAGE.17 USE-PACKAGE.18

 USE-PACKAGE.19 USE-PACKAGE.20 USE-PACKAGE.21 USE-PACKAGE.22

 USE-PACKAGE.23 USE-PACKAGE.ERROR.1 USE-PACKAGE.ERROR.2 DEFPACKAGE.1

 DEFPACKAGE.2 DEFPACKAGE.3 DEFPACKAGE.4 DEFPACKAGE.5 DEFPACKAGE.6

 DEFPACKAGE.7 DEFPACKAGE.8 DEFPACKAGE.9 DEFPACKAGE.10 DEFPACKAGE.11

 DEFPACKAGE.12 DEFPACKAGE.13 DEFPACKAGE.14 DEFPACKAGE.15 DEFPACKAGE.16

 DEFPACKAGE.17 DEFPACKAGE.18 DEFPACKAGE.19 DEFPACKAGE.20 DEFPACKAGE.21

 DEFPACKAGE.22 DEFPACKAGE.23 DEFPACKAGE.24 DEFPACKAGE.25Making G1...

Making G2...

Making G3...

Making G1...

Making G2...

Making G3...

 DEFPACKAGE.26 DEFPACKAGE.ERROR.1 DO-SYMBOLS.1 DO-SYMBOLS.2 DO-SYMBOLS.3

 DO-SYMBOLS.4 DO-SYMBOLS.5 DO-SYMBOLS.6 DO-SYMBOLS.7 DO-SYMBOLS.8

 DO-SYMBOLS.9 DO-SYMBOLS.10 DO-SYMBOLS.11 DO-SYMBOLS.12 DO-SYMBOLS.13

 DO-SYMBOLS.14 DO-SYMBOLS.15 DO-SYMBOLS.16 DO-SYMBOLS.17 DO-SYMBOLS.18

 DO-SYMBOLS.19 DO-SYMBOLS.ERROR.1 DO-EXTERNAL-SYMBOLS.1

 DO-EXTERNAL-SYMBOLS.2 DO-EXTERNAL-SYMBOLS.3 DO-EXTERNAL-SYMBOLS.4

 DO-EXTERNAL-SYMBOLS.5 DO-EXTERNAL-SYMBOLS.6 DO-EXTERNAL-SYMBOLS.7

 DO-EXTERNAL-SYMBOLS.8 DO-EXTERNAL-SYMBOLS.9 DO-EXTERNAL-SYMBOLS.10

 DO-EXTERNAL-SYMBOLS.11 DO-EXTERNAL-SYMBOLS.12 DO-EXTERNAL-SYMBOLS.13

 DO-EXTERNAL-SYMBOLS.14 DO-EXTERNAL-SYMBOLS.15 DO-EXTERNAL-SYMBOLS.16

 DO-EXTERNAL-SYMBOLS.17 DO-EXTERNAL-SYMBOLS.18 DO-EXTERNAL-SYMBOLS.19

 DO-EXTERNAL-SYMBOLS.ERROR.1 DO-ALL-SYMBOLS.ERROR.1 DO-ALL-SYMBOLS.1

 DO-ALL-SYMBOLS.2 DO-ALL-SYMBOLS.3 DO-ALL-SYMBOLS.4 DO-ALL-SYMBOLS.5

 DO-ALL-SYMBOLS.6 DO-ALL-SYMBOLS.7 DO-ALL-SYMBOLS.8 DO-ALL-SYMBOLS.9

 DO-ALL-SYMBOLS.10 DO-ALL-SYMBOLS.11 DO-ALL-SYMBOLS.12 DO-ALL-SYMBOLS.13

 PACKAGEP.1 PACKAGEP.2 PACKAGEP.ERROR.1 PACKAGEP.ERROR.2 PACKAGE-ERROR.1

 PACKAGE-ERROR.2 PACKAGE-ERROR.3 PACKAGE-ERROR.4 PACKAGE-ERROR-PACKAGE.1

 PACKAGE-ERROR-PACKAGE.2 PACKAGE-ERROR-PACKAGE.3 PACKAGE-ERROR-PACKAGE.4

 PACKAGE-ERROR-PACKAGE.ERROR.1 PACKAGE-ERROR-PACKAGE.ERROR.2 KEYWORD.1

 KEYWORD.2 KEYWORD.3 PACKAGE-SHADOWING-SYMBOLS.1

 PACKAGE-SHADOWING-SYMBOLS.2 PACKAGE-SHADOWING-SYMBOLS.3

 PACKAGE-SHADOWING-SYMBOLS.4 PACKAGE-SHADOWING-SYMBOLS.5

 PACKAGE-SHADOWING-SYMBOLS.6 PACKAGE-SHADOWING-SYMBOLS.7

 PACKAGE-SHADOWING-SYMBOLS.ERROR.1 PACKAGE-SHADOWING-SYMBOLS.ERROR.2

 PACKAGE-USE-LIST.1 PACKAGE-USE-LIST.2 PACKAGE-USE-LIST.3

 PACKAGE-USE-LIST.4 PACKAGE-USE-LIST.5 PACKAGE-USE-LIST.6

 PACKAGE-USE-LIST.7 PACKAGE-USE-LIST.ERROR.1 PACKAGE-USE-LIST.ERROR.2

 PACKAGE-USED-BY-LIST.1 PACKAGE-USED-BY-LIST.2 PACKAGE-USED-BY-LIST.3

 PACKAGE-USED-BY-LIST.4 PACKAGE-USED-BY-LIST.5 PACKAGE-USED-BY-LIST.6

 PACKAGE-USED-BY-LIST.7 PACKAGE-USED-BY-LIST.ERROR.1

 PACKAGE-USED-BY-LIST.ERROR.2 IMPORT.1 IMPORT.2 IMPORT.3 IMPORT.4

 IMPORT.5 IMPORT.6 IMPORT.7 IMPORT.8 IMPORT.9 IMPORT.10 IMPORT.11

 IMPORT.12 IMPORT.ERROR.1 IMPORT.ERROR.2 IMPORT.ERROR.3 IMPORT.ERROR.4

 IMPORT.ERROR.5 =.ERROR.1 /=.ERROR.1 <.ERROR.1 <=.ERROR.1 >.ERROR.1

 >=.ERROR.1 =.1 =.2 =.3 =.4 =.5 =.6 =.7 =.8 =.9 =.10 =.11 =.12 =.13 =.14

 =.15 =.16 =.17 =.18 =.19 =.ORDER.1 =.ORDER.2 =.ORDER.3 /=.1 /=.2 /=.3

 /=.4 /=.4A /=.5 /=.6 /=.7 /=.8 /=.9 /=.10 /=.11 /=.12 /=.13 /=.14 /=.15

 /=.17 /=.18 /=.19 /=.ORDER.1 /=.ORDER.2 /=.ORDER.3 <.1 <.2 <.3 <.4 <.5

 <.6 <.7 <.8 <.9 <.10 <.11 <.17 <.18 <.19 <.ORDER.1 <.ORDER.2 <.ORDER.3

 <=.1 <=.2 <=.3 <=.4 <=.5 <=.6 <=.7 <=.8 <=.9 <=.10 <=.17 <=.18 <=.19

 <=.ORDER.1 <=.ORDER.2 <=.ORDER.3 >.1 >.2 >.3 >.4 >.5 >.6 >.7 >.8 >.9

 >.17 >.18 >.19 >.ORDER.1 >.ORDER.2 >.ORDER.3 >=.1 >=.2 >=.3 >=.4 >=.5

 >=.6 >=.7 >=.8 >=.9 >=.17 >=.18 >=.19 >=.ORDER.1 >=.ORDER.2 >=.ORDER.3

 COMPARE-RATIONALS.1 COMPARE-RATIONALS.2 COMPARE-RATIONALS.3

 COMPARE-RATIONALS.4 BIGNUM.FLOAT.COMPARE.1A BIGNUM.FLOAT.COMPARE.1B

 BIGNUM.FLOAT.COMPARE.2A BIGNUM.FLOAT.COMPARE.2B BIGNUM.FLOAT.COMPARE.3A

 BIGNUM.FLOAT.COMPARE.3B BIGNUM.FLOAT.COMPARE.4A BIGNUM.FLOAT.COMPARE.4B

 BIGNUM.FLOAT.COMPARE.5A BIGNUM.FLOAT.COMPARE.5B BIGNUM.FLOAT.COMPARE.6A

 BIGNUM.FLOAT.COMPARE.6B BIGNUM.FLOAT.COMPARE.7 BIGNUM.FLOAT.COMPARE.8

 BIGNUM.SHORT-FLOAT.RANDOM.COMPARE.1

 BIGNUM.SINGLE-FLOAT.RANDOM.COMPARE.1

 BIGNUM.DOUBLE-FLOAT.RANDOM.COMPARE.1 BIGNUM.LONG-FLOAT.RANDOM.COMPARE.1

 RATIONAL.SHORT-FLOAT.RANDOM.COMPARE.1

 RATIONAL.SINGLE-FLOAT.RANDOM.COMPARE.1

 RATIONAL.DOUBLE-FLOAT.RANDOM.COMPARE.1

 RATIONAL.LONG-FLOAT.RANDOM.COMPARE.1 =.ENV.1 /=.ENV.1 <.ENV.1 <=.ENV.1

 >.ENV.1 >=.ENV.1 MAX.ERROR.1 MAX.ERROR.2 MAX.ERROR.3 MAX.1 MAX.2 MAX.3

 MAX.4 MAX.5 MAX.6 MAX.7 MAX.8 MAX.9 MAX.10 MAX.11 MAX.12 MAX.13 MAX.15

 MAX.16 MAX.17 MAX.18 MAX.19 MAX.20 MAX.21 MAX.22 MAX.23 MAX.24 MAX.25

 MAX.26 MAX.27 MAX.28 MAX.29 MAX.30 MAX.31 MAX.32 MAX.33 MAX.34

 MAX.ORDER.1 MAX.ORDER.2 MAX.ORDER.3 MIN.ERROR.1 MIN.ERROR.2 MIN.ERROR.3

 MIN.1 MIN.2 MIN.3 MIN.4 MIN.5 MIN.6 MIN.7 MIN.8 MIN.9 MIN.10 MIN.11

 MIN.12 MIN.13 MIN.15 MIN.16 MIN.17 MIN.18 MIN.19 MIN.20 MIN.21 MIN.22

 MIN.23 MIN.24 MIN.25 MIN.26 MIN.27 MIN.28 MIN.29 MIN.30 MIN.31 MIN.32

 MIN.33 MIN.34 MIN.ORDER.1 MIN.ORDER.2 MIN.ORDER.3 MINUSP.ERROR.1

 MINUSP.ERROR.2 MINUSP.ERROR.3 MINUSP.ERROR.4 MINUSP.1 MINUSP.2 MINUSP.3

 MINUSP.4 MINUSP.5 MINUSP.6 PLUSP.ERROR.1 PLUSP.ERROR.2 PLUSP.ERROR.3

 PLUSP.ERROR.4 PLUSP.1 PLUSP.2 PLUSP.3 PLUSP.4 PLUSP.5 PLUSP.6 PLUSP.7

 ZEROP.ERROR.1 ZEROP.ERROR.2 ZEROP.ERROR.3 ZEROP.ERROR.4 ZEROP.1 ZEROP.2

 ZEROP.3 ZEROP.4 ZEROP.5 ZEROP.6 ZEROP.7 ZEROP.7A ZEROP.8 ZEROP.9

 ZEROP.10 FLOOR.ERROR.1 FLOOR.ERROR.2 FLOOR.1 FLOOR.2 FLOOR.3 FLOOR.4

 FLOOR.5 FLOOR.6 FLOOR.7 FLOOR.8 FLOOR.9 FLOOR.10 FLOOR.11 FLOOR.12

 FLOOR.13 FLOOR.14 FLOOR.15 FLOOR.16 FLOOR.17 FLOOR.18 FLOOR.19

 FFLOOR.ERROR.1 FFLOOR.ERROR.2 FFLOOR.1 FFLOOR.10 FFLOOR.11 FFLOOR.12

 FFLOOR.13 FFLOOR.14 FFLOOR.15 FFLOOR.16 FFLOOR.17 FFLOOR.18 FFLOOR.19

 CEILING.ERROR.1 CEILING.ERROR.2 CEILING.1 CEILING.2 CEILING.3 CEILING.4

 CEILING.5 CEILING.6 CEILING.7 CEILING.8 CEILING.9 CEILING.10 CEILING.11

 CEILING.12 CEILING.13 CEILING.14 CEILING.15 CEILING.16 CEILING.17

 CEILING.18 CEILING.19 FCEILING.ERROR.1 FCEILING.ERROR.2 FCEILING.1

 FCEILING.10 FCEILING.11 FCEILING.12 FCEILING.13 FCEILING.14 FCEILING.15

 FCEILING.16 FCEILING.17 FCEILING.18 FCEILING.19 TRUNCATE.ERROR.1

 TRUNCATE.ERROR.2 TRUNCATE.1 TRUNCATE.2 TRUNCATE.3 TRUNCATE.4 TRUNCATE.5

 TRUNCATE.6 TRUNCATE.7 TRUNCATE.8 TRUNCATE.9 TRUNCATE.10 TRUNCATE.11

 TRUNCATE.12 TRUNCATE.13 TRUNCATE.14 TRUNCATE.15 TRUNCATE.16 TRUNCATE.17

 TRUNCATE.18 TRUNCATE.19 FTRUNCATE.ERROR.1 FTRUNCATE.ERROR.2 FTRUNCATE.1

 FTRUNCATE.10 FTRUNCATE.11 FTRUNCATE.12 FTRUNCATE.13 FTRUNCATE.14

 FTRUNCATE.15 FTRUNCATE.16 FTRUNCATE.17 FTRUNCATE.18 FTRUNCATE.19

 ROUND.ERROR.1 ROUND.ERROR.2 ROUND.1 ROUND.2

Test ROUND.3 failed

Form: (ROUND.3-FN 20000.0)

Expected value: NIL

Actual value: ((-557.5 -557 -0.5 -557.5) (-8703.5 -8703 -0.5 -8703.5)).

 ROUND.4 ROUND.5 ROUND.6 ROUND.7 ROUND.8 ROUND.9 ROUND.10 ROUND.11

 ROUND.12 ROUND.13 ROUND.14 ROUND.15 ROUND.16 ROUND.17 ROUND.18 ROUND.19

 ROUND.20 ROUND.21 FROUND.ERROR.1 FROUND.ERROR.2 FROUND.1 FROUND.10

 FROUND.11 FROUND.12 FROUND.13 FROUND.14 FROUND.15 FROUND.16 FROUND.17

 FROUND.18 FROUND.19 SIN.1 SIN.2 SIN.3 SIN.4 SIN.5 SIN.6 SIN.7 SIN.8

 SIN.9 SIN.10 SIN.11 SIN.12 SIN.13 SIN.14 SIN.15 SIN.16 SIN.17 SIN.18

 SIN.19 SIN.20 SIN.21 SIN.22 SIN.23 SIN.24 SIN.ERROR.1 SIN.ERROR.2

 SIN.ERROR.3 COS.1 COS.2 COS.3 COS.4 COS.5 COS.6 COS.7 COS.8 COS.9

 COS.10 COS.11 COS.12 COS.13 COS.14 COS.15 COS.16 COS.17 COS.18 COS.19

 COS.20 COS.21 COS.22 COS.23 COS.24 COS.ERROR.1 COS.ERROR.2 COS.ERROR.3

 TAN.1 TAN.2 TAN.3 TAN.4 TAN.5 TAN.6 TAN.7 TAN.8 TAN.9 TAN.10 TAN.11

 TAN.12 TAN.13 TAN.14 TAN.15 TAN.16 TAN.17 TAN.18 TAN.19 TAN.20 TAN.21

 TAN.22 TAN.23 TAN.24 TAN.ERROR.1 TAN.ERROR.2 TAN.ERROR.3 ASIN.1 ASIN.2

 ASIN.3 ASIN.4 ASIN.5 ASIN.6 ASIN.7 ASIN.8 ASIN.9 ASIN.ERROR.1

 ASIN.ERROR.2 ASIN.ERROR.3 ACOS.1 ACOS.2 ACOS.3 ACOS.4 ACOS.5 ACOS.6

 ACOS.7 ACOS.8 ACOS.9 ACOS.ERROR.1 ACOS.ERROR.2 ACOS.ERROR.3 ATAN.1

 ATAN.2 ATAN.3 ATAN.4 ATAN.5 ATAN.6 ATAN.7 ATAN.8 ATAN.9 ATAN.10 ATAN.11

 ATAN.12 ATAN.13 ATAN.14 ATAN.ERROR.1 ATAN.ERROR.2 ATAN.ERROR.3

 ATAN.ERROR.4 ATAN.ERROR.5 SINH.1 SINH.2 SINH.3 SINH.4 SINH.5 SINH.6

 SINH.ERROR.1 SINH.ERROR.2 SINH.ERROR.3 COSH.1 COSH.2 COSH.3 COSH.4

 COSH.5 COSH.6 COSH.ERROR.1 COSH.ERROR.2 COSH.ERROR.3 TANH.1 TANH.2

 TANH.3 TANH.4 TANH.5 TANH.6 TANH.ERROR.1 TANH.ERROR.2 TANH.ERROR.3

 ASINH.1 ASINH.2 ASINH.3 ASINH.4 ASINH.5 ASINH.6 ASINH.7 ASINH.ERROR.1

 ASINH.ERROR.2 ASINH.ERROR.3 ACOSH.1 ACOSH.2 ACOSH.3 ACOSH.4 ACOSH.5

 ACOSH.6 ACOSH.7 ACOSH.ERROR.1 ACOSH.ERROR.2 ACOSH.ERROR.3 ATANH.1

 ATANH.2 ATANH.3 ATANH.4 ATANH.5 ATANH.5A ATANH.6 ATANH.7 ATANH.8

 ATANH.ERROR.1 ATANH.ERROR.2 ATANH.ERROR.3 *.1 *.2 *.3 *.4 *.5 *.6 *.7

 *.8 *.9 *.10 *.11 *.12 *.13 *.14 *.15 *.16 *.17 *.18 *.19 *.20 *.21

 *.22 *.23 *.24 *.25E43.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E43.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E43.exp
 *.26 *.27 *.28 TIMES.ORDER.1 TIMES.ORDER.2 PLUS.1

 PLUS.2 PLUS.3 PLUS.4 PLUS.5 PLUS.6 PLUS.7 PLUS.8 PLUS.9 PLUS.10 PLUS.11

 PLUS.12 PLUS.13 PLUS.14 PLUS.15 PLUS.16 PLUS.17 PLUS.18 PLUS.19 PLUS.20

 PLUS.21 PLUS.22 PLUS.23E46.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E46.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E46.exp
 PLUS.24E49.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E49.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E49.exp
 PLUS.25E4C.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E4C.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E4C.exp
 PLUS.26E4F.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E4F.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E4F.exp
 PLUS.27 PLUS.28

 PLUS.ORDER.1 PLUS.ORDER.2E52.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E52.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E52.exp
E55.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E55.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E55.exp
E58.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E58.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E58.exp
E5B.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E5B.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E5B.exp
 PLUS.REASSOCIATION.1E5E.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E5E.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E5E.exp
E61.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E61.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E61.exp
E64.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E64.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E64.exp
E67.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E67.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E67.exp
 PLUS.REASSOCIATION.2E6A.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E6A.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E6A.exp
E6D.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E6D.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E6D.exp
E70.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E70.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E70.exp
E73.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E73.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E73.exp


 PLUS.REASSOCIATION.3E76.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E76.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E76.exp
E79.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E79.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E79.exp
E7C.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E7C.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E7C.exp
E7F.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E7F.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E7F.exp
 PLUS.REASSOCIATION.4 MINUS.ERROR.1 MINUS.1 MINUS.2

 MINUS.3 MINUS.4 MINUS.5 MINUS.6 MINUS.7 MINUS.8 MINUS.9 SUBTRACT.1

 SUBTRACT.2 SUBTRACT.3 SUBTRACT.4 SUBTRACT.5 SUBTRACT.6 /.ERROR.1

 /.ERROR.2 /.ERROR.3 /.ERROR.4 /.ERROR.5 /.ERROR.6 /.ERROR.7 /.ERROR.8

 /.1 /.2 /.3 /.4 /.5 /.6 /.8 /.9 /.10 /.11 /.12 /.13 1+.ERROR.1

 1+.ERROR.2 1+.ERROR.3 |1+.1| |1+.2| |1+.3| |1+.4| |1+.5| |1+.6| |1+.7|

 |1+.8| |1+.9| |1+.10| |1+.11| |1+.12| |1+.13| |1+.14| |1+.15|

 1-.ERROR.1 1-.ERROR.2 1-.ERROR.3 |1-.1| |1-.2| |1-.3| |1-.4| |1-.5|

 |1-.6| |1-.7| |1-.8| |1-.9| |1-.10| |1-.11| |1-.12| |1-.13| |1-.14|

 |1-.15| ABS.ERROR.1 ABS.ERROR.2 ABS.ERROR.3 ABS.1 ABS.2 ABS.3 ABS.4

 ABS.5 ABS.6 ABS.7 ABS.8 ABS.9 ABS.14 ABS.15 ABS.16 ABS.17 ABS.18 ABS.19

 ABS.20 ABS.21 ABS.22 EXP.ERROR.1 EXP.ERROR.2 EXP.ERROR.3 EXP.1 EXP.2

 EXP.3 EXP.ERROR.4 EXP.ERROR.5 EXP.ERROR.6 EXP.ERROR.7 EXP.ERROR.8

 EXP.ERROR.9 EXP.ERROR.10 EXP.ERROR.11 EXPT.ERROR.1 EXPT.ERROR.2

 EXPT.ERROR.3 EXPT.ERROR.4 EXPT.ERROR.5 EXPT.ERROR.6 EXPT.ERROR.7

 EXPT.ERROR.8 EXPT.ERROR.9 EXPT.ERROR.10 EXPT.ERROR.11 EXPT.1 EXPT.2

 EXPT.3 EXPT.4 EXPT.5 EXPT.6 EXPT.7 EXPT.8 EXPT.9 EXPT.10 EXPT.11

 EXPT.12 EXPT.13 EXPT.14 EXPT.15 EXPT.16 EXPT.17 EXPT.18 EXPT.19 EXPT.20

 EXPT.21 EXPT.22 EXPT.23 EXPT.24 EXPT.25 EXPT.26 EXPT.27 EXPT.28

 GCD.ERROR.1 GCD.1 GCD.2 GCD.3 GCD.4 GCD.5 GCD.6 GCD.7 GCD.8 GCD.ORDER.1

 GCD.ORDER.2 GCD.ORDER.3 INCF.1 INCF.2 INCF.3 INCF.4 INCF.5 INCF.6

 INCF.7 INCF.8 INCF.9 INCF.10 INCF.11 INCF.12 INCF.13 INCF.14 INCF.15

 INCF.16 INCF.17 INCF.18 INCF.19 INCF.20 INCF.21 INCF.22 INCF.23

 INCF.ORDER.2 INCF.ORDER.3 INCF.ORDER.4 DECF.1 DECF.2 DECF.3 DECF.4

 DECF.5 DECF.6 DECF.7 DECF.8 DECF.9 DECF.10 DECF.11 DECF.12 DECF.13

 DECF.14 DECF.15 DECF.16 DECF.17 DECF.18 DECF.19 DECF.20 DECF.21 DECF.22

 DECF.23 DECF.ORDER.2 DECF.ORDER.3 DECF.ORDER.4 LCM.ERROR.1 LCM.1 LCM.2

 LCM.3 LCM.4 LCM.5 LCM.6 LCM.7 LCM.8 LCM.9 LCM.10 LCM.11 LCM.12

 LCM.ORDER.1 LCM.ORDER.2 LCM.ORDER.3 LOG.1 LOG.2 LOG.3 LOG.4 LOG.5 LOG.6

 LOG.7 LOG.8 LOG.ERROR.1 LOG.ERROR.2 SIGNUM.ERROR.1 SIGNUM.ERROR.2

 SIGNUM.ERROR.3 SIGNUM.1 SIGNUM.2 SIGNUM.3 SIGNUM.4 SIGNUM.5 SIGNUM.6

 SIGNUM.7 SIGNUM.8 SIGNUM.9 SIGNUM.10 SIGNUM.11 SQRT.ERROR.1

 SQRT.ERROR.2 SQRT.ERROR.3 SQRT.1 SQRT.2 SQRT.3 SQRT.4 SQRT.5 SQRT.7

 SQRT.8 SQRT.9 SQRT.10 SQRT.11 SQRT.12 SQRT.13 SQRT.14 SQRT.15 SQRT.16

 SQRT.17 SQRT.18 SQRT.19 ISQRT.ERROR.1 ISQRT.ERROR.2 ISQRT.ERROR.3

 ISQRT.ERROR.4 ISQRT.ERROR.5 ISQRT.1 ISQRT.2 ISQRT.3 RANDOM.ERROR.1

 RANDOM.ERROR.2 RANDOM.ERROR.3 RANDOM.1 RANDOM.2 RANDOM.3 RANDOM.4

 RANDOM.5 RANDOM.6 RANDOM.7E82.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E82.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E82.exp
 RANDOM.8 RANDOM-STATE-P.ERROR.1

 RANDOM-STATE-P.ERROR.2 RANDOM-STATE-P.1 RANDOM-STATE-P.2

 RANDOM-STATE-P.3 MAKE-RANDOM-STATE.ERROR.1 MAKE-RANDOM-STATE.ERROR.2

 MAKE-RANDOM-STATE.ERROR.3 MAKE-RANDOM-STATE.ERROR.4 MAKE-RANDOM-STATE.1

 MAKE-RANDOM-STATE.2 MAKE-RANDOM-STATE.3 MAKE-RANDOM-STATE.4

 NUMBERP.ERROR.1 NUMBERP.ERROR.2 NUMBERP.ERROR.3 NUMBERP.1 CIS.ERROR.1

 CIS.ERROR.2 CIS.1 CIS.2 CIS.3 CIS.4 COMPLEX.ERROR.1 COMPLEX.ERROR.2

 COMPLEX.1 COMPLEX.2 COMPLEX.3 COMPLEX.4 COMPLEX.5 COMPLEXP.ERROR.1

 COMPLEXP.ERROR.2 COMPLEXP.ERROR.3 COMPLEXP.1 CONJUGATE.ERROR.1

 CONJUGATE.ERROR.2 CONJUGATE.1 CONJUGATE.2 CONJUGATE.3 CONJUGATE.4

 CONJUGATE.5 CONJUGATE.6 CONJUGATE.7 CONJUGATE.8 CONJUGATE.9

 CONJUGATE.10 PHASE.ERROR.1 PHASE.ERROR.2 PHASE.ERROR.3 PHASE.1 PHASE.2

 PHASE.3 PHASE.4 PHASE.5 PHASE.6 PHASE.7 PHASE.8 PHASE.9 PHASE.10

 PHASE.11 PHASE.12 PHASE.13 PHASE.14 PHASE.15 PHASE.16 PHASE.17 PHASE.18

 PHASE.19 PHASE.20 PHASE.21 REALPART.ERROR.1 REALPART.ERROR.2

 REALPART.ERROR.3 REALPART.1 REALPART.2 REALPART.3 REALPART.4

 IMAGPART.ERROR.1 IMAGPART.ERROR.2 IMAGPART.ERROR.3 IMAGPART.1

 IMAGPART.2 IMAGPART.3 IMAGPART.4 REALP.ERROR.1 REALP.ERROR.2

 REALP.ERROR.3 REALP.1 REALP.2 REALP.3 REALP.4 REALP.5 REALP.6

 NUMERATOR.ERROR.1 NUMERATOR.ERROR.2 DENOMINATOR.ERROR.1

 DENOMINATOR.ERROR.2 NUMERATOR-DENOMINATOR.1 NUMERATOR-DENOMINATOR.2

 NUMERATOR-DENOMINATOR.3 NUMERATOR-DENOMINATOR.4 NUMERATOR-DENOMINATOR.5

 RATIONALP.ERROR.1 RATIONALP.ERROR.2 RATIONALP.ERROR.3 RATIONALP.1

 RATIONALP.2 RATIONALP.3 ASH.ERROR.1 ASH.ERROR.2 ASH.ERROR.3 ASH.ERROR.4

 ASH.ERROR.5 ASH.1 ASH.2 ASH.3 ASH.4 ASH.5 ASH.6 ASH.ORDER.1

 INTEGER-LENGTH.ERROR.1 INTEGER-LENGTH.ERROR.2 INTEGER-LENGTH.ERROR.3

 INTEGER-LENGTH.ERROR.4 INTEGER-LENGTH.1 INTEGER-LENGTH.2

 INTEGER-LENGTH.3 INTEGER-LENGTH.4 INTEGERP.ERROR.1 INTEGERP.ERROR.2

 INTEGERP.ERROR.3 INTEGERP.1 INTEGERP.2 PARSE-INTEGER.ERROR.1

 PARSE-INTEGER.ERROR.2 PARSE-INTEGER.ERROR.3 PARSE-INTEGER.ERROR.4

 PARSE-INTEGER.ERROR.5 PARSE-INTEGER.ERROR.5A PARSE-INTEGER.ERROR.6

 PARSE-INTEGER.ERROR.7 PARSE-INTEGER.ERROR.8 PARSE-INTEGER.ERROR.9

 PARSE-INTEGER.ERROR.10 PARSE-INTEGER.ERROR.11 PARSE-INTEGER.ERROR.12

 PARSE-INTEGER.ERROR.13 PARSE-INTEGER.ERROR.14 PARSE-INTEGER.ERROR.15

 PARSE-INTEGER.1 PARSE-INTEGER.2 PARSE-INTEGER.3 PARSE-INTEGER.4

 PARSE-INTEGER.5 PARSE-INTEGER.6 PARSE-INTEGER.7 PARSE-INTEGER.8

 PARSE-INTEGER.9 PARSE-INTEGER.10 PARSE-INTEGER.11 PARSE-INTEGER.12

 PARSE-INTEGER.13 PARSE-INTEGER.14 PARSE-INTEGER.15 PARSE-INTEGER.16

 PARSE-INTEGER.17 PARSE-INTEGER.18 PARSE-INTEGER.19 PARSE-INTEGER.20

 PARSE-INTEGER.22 PARSE-INTEGER.23 PARSE-INTEGER.24 PARSE-INTEGER.25

 PARSE-INTEGER.26 PARSE-INTEGER.27 PARSE-INTEGER.28 PARSE-INTEGER.28A

 PARSE-INTEGER.29 PARSE-INTEGER.29A PARSE-INTEGER.30 PARSE-INTEGER.30A

 PARSE-INTEGER.31 PARSE-INTEGER.32 PARSE-INTEGER.33 PARSE-INTEGER.34

 PARSE-INTEGER.35 PARSE-INTEGER.36 PARSE-INTEGER.ORDER.1 BOOLE.ERROR.1

 BOOLE.ERROR.2 BOOLE.ERROR.3 BOOLE.ERROR.4 BOOLE.ERROR.5 BOOLE.ERROR.6

 BOOLE.ERROR.7 BOOLE.1 BOOLE.2E85.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E85.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E85.exp
E88.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E88.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E88.exp
E8B.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E8B.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E8B.exp
E8E.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E8E.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E8E.exp
E91.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E91.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E91.exp
E94.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E94.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E94.exp
E97.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E97.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E97.exp
E9A.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E9A.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E9A.exp
E9D.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E9D.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/E9D.exp
EA0.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA0.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA0.exp
EA3.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA3.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA3.exp
EA6.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA6.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA6.exp
EA9.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA9.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EA9.exp
EAC.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EAC.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EAC.exp
EAF.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EAF.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EAF.exp
EB2.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EB2.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EB2.exp
 BOOLE.3 BOOLE.4 BOOLE.ORDER.1

 BOOLE.CONSTANTS.1 BOOLE.CONSTANTS.2 BOOLE.CONSTANTS.3 LOGAND.ERROR.1

 LOGAND.ERROR.2 LOGAND.ERROR.3 LOGAND.1 LOGAND.2 LOGAND.3 LOGAND.4

 LOGAND.5 LOGAND.6 LOGAND.7 LOGAND.8 LOGAND.9 LOGAND.ORDER.1

 LOGAND.ORDER.2 LOGANDC1.ERROR.1 LOGANDC1.ERROR.2 LOGANDC1.ERROR.3

 LOGANDC1.ERROR.4 LOGANDC1.ERROR.5 LOGANDC1.1 LOGANDC1.2 LOGANDC1.3

 LOGANDC1.4 LOGANDC1.5 LOGANDC1.6 LOGANDC1.ORDER.1 LOGANDC2.ERROR.1

 LOGANDC2.ERROR.2 LOGANDC2.ERROR.3 LOGANDC2.ERROR.4 LOGANDC2.ERROR.5

 LOGANDC2.1 LOGANDC2.2 LOGANDC2.3 LOGANDC2.4 LOGANDC2.5 LOGANDC2.6

 LOGANDC2.ORDER.1 LOGEQV.ERROR.1 LOGEQV.ERROR.2 LOGEQV.1 LOGEQV.2

 LOGEQV.3 LOGEQV.4 LOGEQV.5 LOGEQV.6 LOGEQV.7 LOGEQV.8 LOGEQV.ORDER.1

 LOGEQV.ORDER.2 LOGIOR.ERROR.1 LOGIOR.ERROR.2 LOGIOR.1 LOGIOR.2 LOGIOR.3

 LOGIOR.4 LOGIOR.5 LOGIOR.6 LOGIOR.7 LOGIOR.8 LOGIOR.ORDER.1

 LOGIOR.ORDER.2 LOGNAND.ERROR.1 LOGNAND.ERROR.2 LOGNAND.ERROR.3

 LOGNAND.ERROR.4 LOGNAND.ERROR.5 LOGNAND.1 LOGNAND.2 LOGNAND.3 LOGNAND.4

 LOGNAND.5 LOGNAND.6 LOGNAND.ORDER.1 LOGNOR.ERROR.1 LOGNOR.ERROR.2

 LOGNOR.ERROR.3 LOGNOR.ERROR.4 LOGNOR.ERROR.5 LOGNOR.1 LOGNOR.2 LOGNOR.3

 LOGNOR.4 LOGNOR.5 LOGNOR.6 LOGNOR.ORDER.1 LOGORC1.ERROR.1

 LOGORC1.ERROR.2 LOGORC1.ERROR.3 LOGORC1.ERROR.4 LOGORC1.ERROR.5

 LOGORC1.1 LOGORC1.2 LOGORC1.2A LOGORC1.3 LOGORC1.4 LOGORC1.5 LOGORC1.6

 LOGORC1.ORDER.1 LOGORC2.ERROR.1 LOGORC2.ERROR.2 LOGORC2.ERROR.3

 LOGORC2.ERROR.4 LOGORC2.ERROR.5 LOGORC2.1 LOGORC2.2 LOGORC2.2A

 LOGORC2.3 LOGORC2.4 LOGORC2.5 LOGORC2.6 LOGORC2.ORDER.1 LOGNOT.ERROR.1

 LOGNOT.ERROR.2 LOGNOT.ERROR.3 LOGNOT.1 LOGNOT.2 LOGNOT.3 LOGNOT.4

 LOGXOR.ERROR.1 LOGXOR.ERROR.2 LOGXOR.1 LOGXOR.2 LOGXOR.3 LOGXOR.4

 LOGXOR.5 LOGXOR.6 LOGXOR.7 LOGXOR.8 LOGXOR.ORDER.1 LOGXOR.ORDER.2

 LOGBITP.ERROR.1 LOGBITP.ERROR.2 LOGBITP.ERROR.3 LOGBITP.ERROR.4

 LOGBITP.ERROR.5 LOGBITP.1 LOGBITP.2 LOGBITP.3 LOGBITP.4 LOGBITP.5

 LOGBITP.6 LOGBITP.7 LOGBITP.8 LOGBITP.ORDER.1 LOGCOUNT.ERROR.1

 LOGCOUNT.ERROR.2 LOGCOUNT.ERROR.3 LOGCOUNT.1 LOGCOUNT.2 LOGCOUNT.3

 LOGCOUNT.4 LOGCOUNT.5 LOGCOUNT.6 LOGCOUNT.7 LOGCOUNT.8 LOGTEST.ERROR.1

 LOGTEST.ERROR.2 LOGTEST.ERROR.3 LOGTEST.ERROR.4 LOGTEST.ERROR.5

 LOGTEST.1 LOGTEST.2 LOGTEST.3 BYTE.ERROR.1 BYTE.ERROR.2 BYTE.ERROR.3

 BYTE.1 BYTE.2 BYTE.3 BYTE.4 BYTE.5 BYTE-SIZE.1 BYTE-POSITION.1

 BYTE-POSITION.ERROR.1 BYTE-POSITION.ERROR.2 BYTE-SIZE.ERROR.1

 BYTE-SIZE.ERROR.2 DEPOSIT-FIELD.ERROR.1 DEPOSIT-FIELD.ERROR.2

 DEPOSIT-FIELD.ERROR.3 DEPOSIT-FIELD.ERROR.4 DEPOSIT-FIELD.1

 DEPOSIT-FIELD.2 DEPOSIT-FIELD.3 DEPOSIT-FIELD.4 DEPOSIT-FIELD.5

 DPB.ERROR.1 DPB.ERROR.2 DPB.ERROR.3 DPB.ERROR.4 DPB.1 DPB.2 DPB.3 DPB.4

 DPB.5 LDB.ERROR.1 LDB.ERROR.2 LDB.ERROR.3 LDB.1 LDB.2 LDB.3 LDB.ORDER.1

 LDB.PLACE.1 LDB.PLACE.2 LDB.PLACE.ORDER.1 MASK-FIELD.ERROR.1

 MASK-FIELD.ERROR.2 MASK-FIELD.ERROR.3 MASK-FIELD.1 MASK-FIELD.2

 MASK-FIELD.3 MASK-FIELD.ORDER.1 MASK-FIELD.PLACE.1 MASK-FIELD.PLACE.2

 MASK-FIELD.PLACE.ORDER.1 FLOAT.ERROR.1 FLOAT.ERROR.2 FLOAT.1 FLOAT.2

 FLOAT.3 FLOAT.4 FLOAT.5 FLOAT.6 FLOAT.7 FLOAT.8 FLOAT.9 FLOAT.10

 FLOAT.11 FLOATP.ERROR.1 FLOATP.ERROR.2 FLOATP.1 FLOATP.2 FLOATP.3

 RATIONAL.ERROR.1 RATIONAL.ERROR.2 RATIONAL.ERROR.3 RATIONAL.ERROR.4

 RATIONAL.1 RATIONAL.2 RATIONAL.3 RATIONALIZE.ERROR.1

 RATIONALIZE.ERROR.2 RATIONALIZE.ERROR.3 RATIONALIZE.ERROR.4

 RATIONALIZE.1 RATIONALIZE.2 RATIONALIZE.3 EVENP.ERROR.1 EVENP.ERROR.2

 EVENP.ERROR.3 EVENP.1 EVENP.3 EVENP.4 EVENP.5 EVENP.6 EVENP.7 EVENP.8

 ODDP.ERROR.1 ODDP.ERROR.2 ODDP.ERROR.3 ODDP.1 ODDP.3 ODDP.4 ODDP.5

 ODDP.6 ODDP.7 ODDP.8 EPSILONS.1 EPSILONS.2 EPSILONS.3 EPSILONS.4

 EPSILONS.5 EPSILONS.6 EPSILONS.7 EPSILONS.8 EPSILONS.9 EPSILONS.10

 EPSILONS.11 EPSILONS.12 EPSILONS.13 REAL.1 REAL.2 REAL.3 REAL.4

 UPGRADED-COMPLEX-PART-TYPE.1 UPGRADED-COMPLEX-PART-TYPE.2

 UPGRADED-COMPLEX-PART-TYPE.3 UPGRADED-COMPLEX-PART-TYPE.4

 UPGRADED-COMPLEX-PART-TYPE.5 UPGRADED-COMPLEX-PART-TYPE.6

 UPGRADED-COMPLEX-PART-TYPE.7 UPGRADED-COMPLEX-PART-TYPE.8

 UPGRADED-COMPLEX-PART-TYPE.9 UPGRADED-COMPLEX-PART-TYPE.ERROR.1

 UPGRADED-COMPLEX-PART-TYPE.ERROR.2 ARITHMETHIC-ERROR.1

 ARITHMETHIC-ERROR.2 ARITHMETIC-ERROR.3

 ARITHMETIC-ERROR-OPERATION.ERROR.1 ARITHMETIC-ERROR-OPERATION.ERROR.2

 ARITHMETIC-ERROR-OPERANDS.ERROR.1 ARITHMETIC-ERROR-OPERANDS.ERROR.2

 COPY-SEQ.1 COPY-SEQ.2 COPY-SEQ.3 COPY-SEQ.4 COPY-SEQ.5 COPY-SEQ.6

 COPY-SEQ.7 COPY-SEQ.8 COPY-SEQ.9 COPY-SEQ.10 COPY-SEQ.11 COPY-SEQ.12

 COPY-SEQ.13 COPY-SEQ.14 COPY-SEQ.15 COPY-SEQ.16 COPY-SEQ.17 COPY-SEQ.18

 COPY-SEQ.20 COPY-SEQ.21 COPY-SEQ.22 COPY-SEQ.23 COPY-SEQ.24

 COPY-SEQ.ORDER.1 COPY-SEQ.FOLD.1 COPY-SEQ.FOLD.2 COPY-SEQ.FOLD.3

 COPY-SEQ.FOLD.4 COPY-SEQ.ERROR.1 COPY-SEQ.ERROR.4 COPY-SEQ.ERROR.5

 COPY-SEQ.ERROR.6 ELT.1 ELT.1A ELT.1B ELT.2 ELT.3 ELT.4 ELT.5 ELT.5A

 ELT.6 ELT.7 ELT.8 ELT.9 ELT.10 ELT.11 ELT.12 ELT.13 ELT.14 ELT.15

 ELT.16 ELT.17 ELT.18 ELT.19 ELT.ORDER.1 ELT.ORDER.2 ELT-V.1 ELT-V.3

 ELT-V.4 ELT-V.5 ELT-V.6 ELT-V.7 ELT-V.8 ELT-V.9 ELT-V.10 ELT-V.11

 ELT-V.12 ELT-V.13 ELT-ADJ-ARRAY.1 ELT-ADJ-ARRAY.3 ELT-ADJ-ARRAY.4

 ELT-ADJ-ARRAY.5 ELT-ADJ-ARRAY.6 ELT-ADJ-ARRAY.7 ELT-ADJ-ARRAY.8

 ELT-ADJ-ARRAY.9 ELT-ADJ-ARRAY.10 ELT-ADJ-ARRAY.11 ELT-ADJ-ARRAY.12

 ELT-ADJ-ARRAY.13 ELT-DISPLACED-ARRAY.1 ELT-DISPLACED-ARRAY.2

 ELT-DISPLACED-ARRAY.3 ELT-FILL-POINTER.1 ELT-FILL-POINTER.2

 ELT-FILL-POINTER.3 ELT-FILL-POINTER.4 ELT-FILL-POINTER.5

 ELT-FILL-POINTER.6 ELT-FILL-POINTER.7 ELT-FILL-POINTER.8

 ELT.SPECIAL-STRINGS.1 ELT.SPECIAL-VECTORS.1 ELT.SPECIAL-VECTORS.2

 ELT.SPECIAL-VECTORS.3 ELT.SPECIAL-VECTORS.4 ELT.ERROR.1 ELT.ERROR.2

 ELT.ERROR.3 ELT.ERROR.4 ELT.ERROR.5 FILL.ERROR.1 FILL.ERROR.2

 FILL.ERROR.3 FILL.ERROR.4 FILL.ERROR.5 FILL.ERROR.6 FILL.ERROR.7

 FILL.ERROR.8 FILL.ERROR.10 FILL.ERROR.11 ARRAY-FILL-1 ARRAY-FILL-2

 ARRAY-FILL-3 ARRAY-FILL-4 ARRAY-FILL-5 ARRAY-FILL-6 ARRAY-FILL-7

 ARRAY-FILL-8 ARRAY-FILL-9 ARRAY-FILL-10 ARRAY-FIXNUM-FILL-1

 ARRAY-FIXNUM-FILL-2 ARRAY-FIXNUM-FILL-3 ARRAY-FIXNUM-FILL-4

 ARRAY-FIXNUM-FILL-5 ARRAY-FIXNUM-FILL-6 ARRAY-FIXNUM-FILL-7

 ARRAY-FIXNUM-FILL-8 ARRAY-FIXNUM-FILL-9 ARRAY-FIXNUM-FILL-10

 ARRAY-UNSIGNED-BYTE8-FILL-1 ARRAY-UNSIGNED-BYTE8-FILL-2

 ARRAY-UNSIGNED-BYTE8-FILL-3 ARRAY-UNSIGNED-BYTE8-FILL-4

 ARRAY-UNSIGNED-BYTE8-FILL-5 ARRAY-UNSIGNED-BYTE8-FILL-6

 ARRAY-UNSIGNED-BYTE8-FILL-7 ARRAY-UNSIGNED-BYTE8-FILL-8

 ARRAY-UNSIGNED-BYTE8-FILL-9 ARRAY-UNSIGNED-BYTE8-FILL-10

 ARRAY-FILL-POINTER-FILL.1 ARRAY-FILL-POINTER-FILL.2 FILL.STRING.1

 FILL.STRING.2 FILL.STRING.3 FILL.STRING.4 FILL.STRING.5 FILL.STRING.6

 FILL.STRING.7 FILL.STRING.8 FILL.STRING.9 FILL.STRING.10

 FILL.BIT-VECTOR.1 FILL.BIT-VECTOR.2 FILL.BIT-VECTOR.3 FILL.BIT-VECTOR.4

 FILL.BIT-VECTOR.5 FILL.BIT-VECTOR.6 FILL.BIT-VECTOR.7 FILL.BIT-VECTOR.8

 FILL.BIT-VECTOR.9 FILL.ALLOW-OTHER-KEYS.1 FILL.ALLOW-OTHER-KEYS.2

 FILL.ALLOW-OTHER-KEYS.3 FILL.ALLOW-OTHER-KEYS.4 FILL.ALLOW-OTHER-KEYS.5

 FILL.ALLOW-OTHER-KEYS.6 FILL.ALLOW-OTHER-KEYS.7 FILL.ORDER.1

 FILL.ORDER.2 FILL.ORDER.3 FILL.ORDER.4 FILL.SPECIALIZED-STRINGS.1

 FILL.SPECIALIZED-STRINGS.2 FILL.SPECIALIZED-STRINGS.3

 FILL.SPECIALIZED-STRINGS.4 FILL.SPECIALIZED-VECTORS.1

 FILL.SPECIALIZED-VECTORS.2 FILL.SPECIALIZED-VECTORS.3

 ARRAY-STRING-FILL.1 ARRAY-STRING-FILL.2 ARRAY-STRING-FILL.3

 ARRAY-STRING-FILL.4 ARRAY-STRING-FILL.5 MAKE-SEQUENCE.1 MAKE-SEQUENCE.2

 MAKE-SEQUENCE.3 MAKE-SEQUENCE.4 MAKE-SEQUENCE.5 MAKE-SEQUENCE.6

 MAKE-SEQUENCE.7 MAKE-SEQUENCE.8 MAKE-SEQUENCE.9 MAKE-SEQUENCE.10

 MAKE-SEQUENCE.11 MAKE-SEQUENCE.12 MAKE-SEQUENCE.13 MAKE-SEQUENCE.14

 MAKE-SEQUENCE.15 MAKE-SEQUENCE.16 MAKE-SEQUENCE.17 MAKE-SEQUENCE.18

 MAKE-SEQUENCE.19 MAKE-SEQUENCE.20 MAKE-SEQUENCE.21 MAKE-SEQUENCE.22

 MAKE-SEQUENCE.23 MAKE-SEQUENCE.24 MAKE-SEQUENCE.25 MAKE-SEQUENCE.27

 MAKE-SEQUENCE.28 MAKE-SEQUENCE.29 MAKE-SEQUENCE.30 MAKE-SEQUENCE.31

 MAKE-SEQUENCE.32 MAKE-SEQUENCE.33 MAKE-SEQUENCE.34 MAKE-SEQUENCE.35

 MAKE-SEQUENCE.36 MAKE-SEQUENCE.37 MAKE-SEQUENCE.38 MAKE-SEQUENCE.39

 MAKE-SEQUENCE.40 MAKE-SEQUENCE.41 MAKE-SEQUENCE.42 MAKE-SEQUENCE.43

 MAKE-SEQUENCE.44 MAKE-SEQUENCE.45 MAKE-SEQUENCE.46 MAKE-SEQUENCE.47

 MAKE-SEQUENCE.48 MAKE-SEQUENCE.49 MAKE-SEQUENCE.50 MAKE-SEQUENCE.51

 MAKE-SEQUENCE.52 MAKE-SEQUENCE.53 MAKE-SEQUENCE.54 MAKE-SEQUENCE.55

 MAKE-SEQUENCE.56 MAKE-SEQUENCE.57 MAKE-SEQUENCE.58

 MAKE-SEQUENCE.ALLOW-OTHER-KEYS.1 MAKE-SEQUENCE.ALLOW-OTHER-KEYS.2

 MAKE-SEQUENCE.ALLOW-OTHER-KEYS.3 MAKE-SEQUENCE.ALLOW-OTHER-KEYS.4

 MAKE-SEQUENCE.ALLOW-OTHER-KEYS.5 MAKE-SEQUENCE.KEYWORDS.6

 MAKE-SEQUENCE.ERROR.1 MAKE-SEQUENCE.ERROR.2 MAKE-SEQUENCE.ERROR.3

 MAKE-SEQUENCE.ERROR.4 MAKE-SEQUENCE.ERROR.5 MAKE-SEQUENCE.ERROR.6

 MAKE-SEQUENCE.ERROR.7 MAKE-SEQUENCE.ERROR.8 MAKE-SEQUENCE.ERROR.9

 MAKE-SEQUENCE.ERROR.10 MAKE-SEQUENCE.ERROR.11 MAKE-SEQUENCE.ERROR.12

 MAKE-SEQUENCE.ERROR.13 MAKE-SEQUENCE.ERROR.14 MAKE-SEQUENCE.ERROR.15

 MAKE-SEQUENCE.ERROR.16 MAKE-SEQUENCE.ORDER.1 MAKE-SEQUENCE.ORDER.2

 MAKE-SEQUENCE.FOLD.1 MAKE-SEQUENCE.FOLD.2 MAKE-SEQUENCE.FOLD.3

 MAKE-SEQUENCE.FOLD.4 MAP-ARRAY.1 MAP-ARRAY.2 MAP-ARRAY.3 MAP-ARRAY.4

 MAP-ARRAY.5 MAP-ARRAY.6 MAP-ARRAY.9 MAP-ARRAY.10 MAP-ARRAY.11

 MAP-ARRAY.12 MAP-ARRAY.13 MAP-ARRAY.14 MAP-BIT-VECTOR.15

 MAP-BIT-VECTOR.16 MAP-BIT-VECTOR.17 MAP-BIT-VECTOR.18 MAP-BIT-VECTOR.19

 MAP-BIT-VECTOR.20 MAP-BIT-VECTOR.21 MAP-BIT-VECTOR.22 MAP-BIT-VECTOR.23

 MAP-BIT-VECTOR.24 MAP-BIT-VECTOR.25 MAP-STRING.26 MAP-STRING.27

 MAP-STRING.28 MAP-STRING.29 MAP-STRING.30 MAP-NIL.33 MAP-NIL.34

 MAP-NIL.35 MAP-NIL.36 MAP-NULL.1 MAP-CONS.1 MAP.37 MAP.38 MAP.39 MAP.40

 MAP.41 MAP.42 MAP.43 MAP.44 MAP.45 MAP.46 MAP.47 MAP.48 MAP.ERROR.1

 MAP.ERROR.1A MAP.ERROR.2 MAP.ERROR.3 MAP.ERROR.4 MAP.ERROR.5

 MAP.ERROR.6 MAP.ERROR.7 MAP.ERROR.8 MAP.ERROR.9 MAP.ERROR.10

Test MAP.ERROR.11 failed

Form: (LET ((TYPE '(OR (VECTOR T 5) (VECTOR T 10))))

        (IF (SUBTYPEP TYPE 'VECTOR)

            (EVAL

             (SI:QUASIQUOTE

              (SIGNALS-ERROR (MAP '(SI:UNQUOTE TYPE) #'IDENTITY '(1 2 3 4 5 6))

                             TYPE-ERROR)))

            T))

Expected value: T

Actual values: NIL

               #(1 2 3 4 5 6).

 MAP.ERROR.12 MAP.ERROR.13 MAP.FILL.1 MAP.FILL.2 MAP.FILL.3 MAP.FILL.4

 MAP.FILL.5 MAP.FILL.6 MAP.SPECIALIZED-STRING.1 MAP.SPECIALIZED-STRING.2

 MAP.SPECIALIZED-STRING.3 MAP.SPECIALIZED-VECTOR.1

 MAP.SPECIALIZED-VECTOR.2 MAP.SPECIALIZED-VECTOR.3

 MAP.SPECIALIZED-VECTOR.4 MAP.SPECIALIZED-VECTOR.5

 MAP.SPECIALIZED-VECTOR.6 MAP.SPECIALIZED-VECTOR.7 MAP.ORDER.1

 MAP.FOLD.1 MAP-INTO-LIST.1 MAP-INTO-LIST.2 MAP-INTO-LIST.3

 MAP-INTO-LIST.4 MAP-INTO-LIST.5 MAP-INTO-LIST.6 MAP-INTO-LIST.7

 MAP-INTO-LIST.8 MAP-INTO-ARRAY.1 MAP-INTO-ARRAY.2 MAP-INTO-ARRAY.3

 MAP-INTO-ARRAY.4 MAP-INTO-ARRAY.5 MAP-INTO-ARRAY.6 MAP-INTO-ARRAY.7

 MAP-INTO-ARRAY.8 MAP-INTO-ARRAY.9 MAP-INTO-ARRAY.10 MAP-INTO-ARRAY.11

 MAP-INTO-STRING.1 MAP-INTO-STRING.2 MAP-INTO-STRING.3 MAP-INTO-STRING.4

 MAP-INTO-STRING.5 MAP-INTO-STRING.6 MAP-INTO-STRING.7 MAP-INTO-STRING.8

 MAP-INTO-STRING.9 MAP-INTO-STRING.10 MAP-INTO-STRING.11

 MAP-INTO-STRING.12 MAP-INTO-STRING.13 MAP-INTO-STRING.14

 MAP-INTO.BIT-VECTOR.1 MAP-INTO.BIT-VECTOR.2 MAP-INTO.BIT-VECTOR.3

 MAP-INTO.BIT-VECTOR.4 MAP-INTO.BIT-VECTOR.5 MAP-INTO.BIT-VECTOR.6

 MAP-INTO.BIT-VECTOR.7 MAP-INTO.BIT-VECTOR.8 MAP-INTO.BIT-VECTOR.9

 MAP-INTO.SPECIALIZED-VECTOR.1 MAP-INTO.SPECIALIZED-VECTOR.2

 MAP-INTO.SPECIALIZED-VECTOR.3 MAP-INTO.SPECIALIZED-VECTOR.4

 MAP-INTO.SPECIALIZED-VECTOR.5 MAP-INTO.SPECIALIZED-VECTOR.6

 MAP-INTO.SPECIALIZED-VECTOR.7 MAP-INTO.SPECIALIZED-VECTOR.8

 MAP-INTO.ERROR.1 MAP-INTO.ERROR.2 MAP-INTO.ERROR.3 MAP-INTO.ERROR.4

 MAP-INTO.ERROR.5 MAP-INTO.ERROR.6 MAP-INTO.ERROR.7 MAP-INTO.ERROR.8

 MAP-INTO.ORDER.1 MAP-INTO.ORDER.2 REDUCE-LIST.1 REDUCE-LIST.2

 REDUCE-LIST.3 REDUCE-LIST.4 REDUCE-LIST.5 REDUCE-LIST.6 REDUCE-LIST.7

 REDUCE-LIST.8 REDUCE-LIST.9 REDUCE-LIST.10 REDUCE-LIST.11

 REDUCE-LIST.12 REDUCE-LIST.13 REDUCE-LIST.14 REDUCE-LIST.15

 REDUCE-LIST.16 REDUCE-LIST.17 REDUCE-ARRAY.1 REDUCE-ARRAY.2

 REDUCE-ARRAY.3 REDUCE-ARRAY.4 REDUCE-ARRAY.5 REDUCE-ARRAY.6

 REDUCE-ARRAY.7 REDUCE-ARRAY.8 REDUCE-ARRAY.9 REDUCE-ARRAY.10

 REDUCE-ARRAY.11 REDUCE-ARRAY.12 REDUCE-ARRAY.13 REDUCE-ARRAY.14

 REDUCE-ARRAY.15 REDUCE-ARRAY.16 REDUCE-ARRAY.17 REDUCE-ARRAY.18

 REDUCE-ARRAY.19 REDUCE-ARRAY.20 REDUCE-ARRAY.21 REDUCE-ARRAY.22

 REDUCE-ARRAY.23 REDUCE-ARRAY.24 REDUCE-ARRAY.25 REDUCE.ERROR.1

 REDUCE.ERROR.2 REDUCE.ERROR.3 REDUCE.ERROR.4 REDUCE.ERROR.5

 REDUCE.ERROR.6 REDUCE.ERROR.7 REDUCE.ERROR.8 REDUCE.ERROR.9

 REDUCE.ERROR.10 REDUCE-STRING.1 REDUCE-STRING.2 REDUCE-STRING.3

 REDUCE-STRING.4 REDUCE-STRING.5 REDUCE-STRING.6 REDUCE-STRING.7

 REDUCE-STRING.8 REDUCE-STRING.9 REDUCE-STRING.10 REDUCE-STRING.11

 REDUCE-STRING.12 REDUCE-STRING.13 REDUCE-STRING.14 REDUCE-STRING.15

 REDUCE-STRING.16 REDUCE-STRING.17 REDUCE-STRING.18 REDUCE-STRING.19

 REDUCE-STRING.20 REDUCE-BITSTRING.1 REDUCE-BITSTRING.2

 REDUCE-BITSTRING.3 REDUCE-BITSTRING.4 REDUCE-BITSTRING.5

 REDUCE-BITSTRING.6 REDUCE-BITSTRING.7 REDUCE-BITSTRING.8

 REDUCE-BITSTRING.9 REDUCE-BITSTRING.10 REDUCE-BITSTRING.11

 REDUCE-BITSTRING.12 REDUCE-BITSTRING.13 REDUCE-BITSTRING.14

 REDUCE-BITSTRING.15 REDUCE-BITSTRING.16 REDUCE-BITSTRING.17

 REDUCE-BITSTRING.18 REDUCE.ORDER.1 REDUCE.ORDER.2 REDUCE.ORDER.3

 REDUCE.ALLOW-OTHER-KEYS.1 REDUCE.ALLOW-OTHER-KEYS.2

 REDUCE.ALLOW-OTHER-KEYS.3 REDUCE.ALLOW-OTHER-KEYS.4

 REDUCE.ALLOW-OTHER-KEYS.5 REDUCE.ALLOW-OTHER-KEYS.6

 REDUCE.ALLOW-OTHER-KEYS.7 REDUCE.ALLOW-OTHER-KEYS.8 REDUCE.KEYWORDS.9

 COUNT-LIST.1 COUNT-LIST.2 COUNT-LIST.3 COUNT-LIST.4 COUNT-LIST.5

 COUNT-LIST.6 COUNT-LIST.7 COUNT-LIST.8 COUNT-LIST.9 COUNT-LIST.10

 COUNT-LIST.11 COUNT-LIST.12 COUNT-LIST.13 COUNT-LIST.14 COUNT-LIST.15

 COUNT-LIST.16 COUNT-LIST.17 COUNT-LIST.18

 COUNT-LIST.TEST-AND-TEST-NOT.1 COUNT-LIST.TEST-AND-TEST-NOT.2

 COUNT-VECTOR.1 COUNT-VECTOR.2 COUNT-VECTOR.3 COUNT-VECTOR.4

 COUNT-VECTOR.5 COUNT-VECTOR.6 COUNT-VECTOR.7 COUNT-VECTOR.8

 COUNT-VECTOR.9 COUNT-VECTOR.10 COUNT-VECTOR.11 COUNT-VECTOR.12

 COUNT-VECTOR.13 COUNT-VECTOR.14 COUNT-VECTOR.15 COUNT-VECTOR.16

 COUNT-VECTOR.17 COUNT-VECTOR.18 COUNT-VECTOR.TEST-AND-TEST-NOT.1

 COUNT-VECTOR.TEST-AND-TEST-NOT.2 COUNT-FILLED-VECTOR.1

 COUNT-FILLED-VECTOR.2 COUNT-FILLED-VECTOR.3 COUNT-FILLED-VECTOR.4

 COUNT-FILLED-VECTOR.5 COUNT-FILLED-VECTOR.6 COUNT-FILLED-VECTOR.7

 COUNT-FILLED-VECTOR.8 COUNT-FILLED-VECTOR.9 COUNT-FILLED-VECTOR.10

 COUNT-FILLED-VECTOR.11 COUNT-FILLED-VECTOR.12 COUNT-FILLED-VECTOR.13

 COUNT-FILLED-VECTOR.14 COUNT-FILLED-VECTOR.15 COUNT-FILLED-VECTOR.16

 COUNT-FILLED-VECTOR.17 COUNT-FILLED-VECTOR.18 COUNT-FILLED-VECTOR.19

 COUNT-FILLED-VECTOR.20 COUNT.SPECIAL-VECTOR.1 COUNT.SPECIAL-VECTOR.2

 COUNT.SPECIAL-VECTOR.3 COUNT.SPECIAL-VECTOR.4 COUNT-BIT-VECTOR.1

 COUNT-BIT-VECTOR.2 COUNT-BIT-VECTOR.3 COUNT-BIT-VECTOR.4

 COUNT-BIT-VECTOR.5 COUNT-BIT-VECTOR.6 COUNT-BIT-VECTOR.7

 COUNT-BIT-VECTOR.8 COUNT-BIT-VECTOR.9 COUNT-BIT-VECTOR.10

 COUNT-BIT-VECTOR.11 COUNT-BIT-VECTOR.12 COUNT-BIT-VECTOR.13

 COUNT-BIT-VECTOR.14 COUNT-BIT-VECTOR.15 COUNT-BIT-VECTOR.16

 COUNT-BIT-VECTOR.17 COUNT-BIT-VECTOR.18 COUNT-BIT-VECTOR.19

 COUNT-BIT-VECTOR.20 COUNT-BIT-VECTOR.21 COUNT-BIT-VECTOR.22

 COUNT-BIT-VECTOR.TEST-AND-TEST-NOT.1

 COUNT-BIT-VECTOR.TEST-AND-TEST-NOT.2 COUNT-STRING.1 COUNT-STRING.2

 COUNT-STRING.3 COUNT-STRING.4 COUNT-STRING.5 COUNT-STRING.6

 COUNT-STRING.7 COUNT-STRING.8 COUNT-STRING.9 COUNT-STRING.10

 COUNT-STRING.11 COUNT-STRING.12 COUNT-STRING.13 COUNT-STRING.14

 COUNT-STRING.15 COUNT-STRING.16 COUNT-STRING.17 COUNT-STRING.18

 COUNT-STRING.19 COUNT-STRING.20 COUNT-STRING.21 COUNT-STRING.22

 COUNT-STRING.23 COUNT-STRING.TEST-AND-TEST-NOT.1

 COUNT-STRING.TEST-AND-TEST-NOT.2 COUNT.ORDER.1 COUNT.ORDER.2

 COUNT.ALLOW-OTHER-KEYS.1 COUNT.ALLOW-OTHER-KEYS.2

 COUNT.ALLOW-OTHER-KEYS.3 COUNT.KEYWORDS.4 COUNT.ALLOW-OTHER-KEYS.5

 COUNT.ERROR.1 COUNT.ERROR.4 COUNT.ERROR.5 COUNT.ERROR.6 COUNT.ERROR.7

 COUNT.ERROR.8 COUNT.ERROR.9 COUNT.ERROR.10 COUNT.ERROR.11

 COUNT.ERROR.12 COUNT.ERROR.13 COUNT.ERROR.14 COUNT.ERROR.15

 COUNT-IF-LIST.1 COUNT-IF-LIST.2 COUNT-IF-LIST.3 COUNT-IF-LIST.4

 COUNT-IF-LIST.5 COUNT-IF-LIST.6 COUNT-IF-LIST.8 COUNT-IF-LIST.9

 COUNT-IF-LIST.10 COUNT-IF-LIST.11 COUNT-IF-LIST.12 COUNT-IF-LIST.13

 COUNT-IF-LIST.14 COUNT-IF-LIST.15 COUNT-IF-LIST.16 COUNT-IF-VECTOR.1

 COUNT-IF-VECTOR.2 COUNT-IF-VECTOR.3 COUNT-IF-VECTOR.4 COUNT-IF-VECTOR.5

 COUNT-IF-VECTOR.6 COUNT-IF-VECTOR.8 COUNT-IF-VECTOR.9

 COUNT-IF-VECTOR.10 COUNT-IF-VECTOR.11 COUNT-IF-VECTOR.12

 COUNT-IF-VECTOR.13 COUNT-IF-VECTOR.14 COUNT-IF-VECTOR.15

 COUNT-IF-VECTOR.16 COUNT-IF-NONSIMPLE-VECTOR.1

 COUNT-IF-NONSIMPLE-VECTOR.2 COUNT-IF-NONSIMPLE-VECTOR.3

 COUNT-IF-NONSIMPLE-VECTOR.4 COUNT-IF-NONSIMPLE-VECTOR.5

 COUNT-IF-NONSIMPLE-VECTOR.6 COUNT-IF-NONSIMPLE-VECTOR.8

 COUNT-IF-NONSIMPLE-VECTOR.9 COUNT-IF-NONSIMPLE-VECTOR.10

 COUNT-IF-NONSIMPLE-VECTOR.11 COUNT-IF-NONSIMPLE-VECTOR.12

 COUNT-IF-NONSIMPLE-VECTOR.13 COUNT-IF-NONSIMPLE-VECTOR.14

 COUNT-IF-NONSIMPLE-VECTOR.15 COUNT-IF-NONSIMPLE-VECTOR.16

 COUNT-IF-NONSIMPLE-VECTOR.17 COUNT-IF.SPECIAL-VECTOR.1

 COUNT-IF.SPECIAL-VECTOR.2 COUNT-IF.SPECIAL-VECTOR.3

 COUNT-IF.SPECIAL-VECTOR.4 COUNT-IF-BIT-VECTOR.1 COUNT-IF-BIT-VECTOR.2

 COUNT-IF-BIT-VECTOR.3 COUNT-IF-BIT-VECTOR.4 COUNT-IF-BIT-VECTOR.5

 COUNT-IF-BIT-VECTOR.6 COUNT-IF-BIT-VECTOR.8 COUNT-IF-BIT-VECTOR.10

 COUNT-IF-BIT-VECTOR.11 COUNT-IF-BIT-VECTOR.12 COUNT-IF-BIT-VECTOR.13

 COUNT-IF-BIT-VECTOR.14 COUNT-IF-BIT-VECTOR.15 COUNT-IF-BIT-VECTOR.16

 COUNT-IF-BIT-VECTOR.17 COUNT-IF-STRING.1 COUNT-IF-STRING.2

 COUNT-IF-STRING.3 COUNT-IF-STRING.4 COUNT-IF-STRING.5 COUNT-IF-STRING.6

 COUNT-IF-STRING.8 COUNT-IF-STRING.11 COUNT-IF-STRING.12

 COUNT-IF-STRING.13 COUNT-IF-STRING.14 COUNT-IF-STRING.15

 COUNT-IF-STRING.16 COUNT-IF-STRING.17 COUNT-IF-STRING.18

 COUNT-IF.ORDER.1 COUNT-IF.ORDER.2 COUNT-IF.ALLOW-OTHER-KEYS.1

 COUNT-IF.ALLOW-OTHER-KEYS.2 COUNT-IF.ALLOW-OTHER-KEYS.3

 COUNT-IF.KEYWORDS.4 COUNT-IF.ALLOW-OTHER-KEYS.5 COUNT-IF.ERROR.1

 COUNT-IF.ERROR.4 COUNT-IF.ERROR.5 COUNT-IF.ERROR.6 COUNT-IF.ERROR.7

 COUNT-IF.ERROR.8 COUNT-IF.ERROR.9 COUNT-IF.ERROR.10 COUNT-IF.ERROR.11

 COUNT-IF.ERROR.12 COUNT-IF.ERROR.13 COUNT-IF.ERROR.14 COUNT-IF.ERROR.15

 COUNT-IF-NOT-LIST.1 COUNT-IF-NOT-LIST.2 COUNT-IF-NOT-LIST.3

 COUNT-IF-NOT-LIST.4 COUNT-IF-NOT-LIST.5 COUNT-IF-NOT-LIST.6

 COUNT-IF-NOT-LIST.8 COUNT-IF-NOT-LIST.9 COUNT-IF-NOT-LIST.10

 COUNT-IF-NOT-LIST.11 COUNT-IF-NOT-LIST.12 COUNT-IF-NOT-LIST.13

 COUNT-IF-NOT-LIST.14 COUNT-IF-NOT-LIST.15 COUNT-IF-NOT-LIST.16

 COUNT-IF-NOT-VECTOR.1 COUNT-IF-NOT-VECTOR.2 COUNT-IF-NOT-VECTOR.3

 COUNT-IF-NOT-VECTOR.4 COUNT-IF-NOT-VECTOR.5 COUNT-IF-NOT-VECTOR.6

 COUNT-IF-NOT-VECTOR.8 COUNT-IF-NOT-VECTOR.9 COUNT-IF-NOT-VECTOR.10

 COUNT-IF-NOT-VECTOR.11 COUNT-IF-NOT-VECTOR.12 COUNT-IF-NOT-VECTOR.13

 COUNT-IF-NOT-VECTOR.14 COUNT-IF-NOT-VECTOR.15 COUNT-IF-NOT-VECTOR.16

 COUNT-IF-NOT-NONSIMPLE-VECTOR.1 COUNT-IF-NOT-NONSIMPLE-VECTOR.2

 COUNT-IF-NOT-NONSIMPLE-VECTOR.3 COUNT-IF-NOT-NONSIMPLE-VECTOR.4

 COUNT-IF-NOT-NONSIMPLE-VECTOR.5 COUNT-IF-NOT-NONSIMPLE-VECTOR.6

 COUNT-IF-NOT-NONSIMPLE-VECTOR.8 COUNT-IF-NOT-NONSIMPLE-VECTOR.9

 COUNT-IF-NOT-NONSIMPLE-VECTOR.10 COUNT-IF-NOT-NONSIMPLE-VECTOR.11

 COUNT-IF-NOT-NONSIMPLE-VECTOR.12 COUNT-IF-NOT-NONSIMPLE-VECTOR.13

 COUNT-IF-NOT-NONSIMPLE-VECTOR.14 COUNT-IF-NOT-NONSIMPLE-VECTOR.15

 COUNT-IF-NOT-NONSIMPLE-VECTOR.16 COUNT-IF-NOT-NONSIMPLE-VECTOR.17

 COUNT-IF-NOT.SPECIAL-VECTOR.2 COUNT-IF-NOT.SPECIAL-VECTOR.3

 COUNT-IF-NOT.SPECIAL-VECTOR.4 COUNT-IF-NOT-BIT-VECTOR.1

 COUNT-IF-NOT-BIT-VECTOR.2 COUNT-IF-NOT-BIT-VECTOR.3

 COUNT-IF-NOT-BIT-VECTOR.4 COUNT-IF-NOT-BIT-VECTOR.5

 COUNT-IF-NOT-BIT-VECTOR.6 COUNT-IF-NOT-BIT-VECTOR.8

 COUNT-IF-NOT-BIT-VECTOR.10 COUNT-IF-NOT-BIT-VECTOR.11

 COUNT-IF-NOT-BIT-VECTOR.12 COUNT-IF-NOT-BIT-VECTOR.13

 COUNT-IF-NOT-BIT-VECTOR.14 COUNT-IF-NOT-BIT-VECTOR.15

 COUNT-IF-NOT-BIT-VECTOR.16 COUNT-IF-NOT-BIT-VECTOR.17

 COUNT-IF-NOT-STRING.1 COUNT-IF-NOT-STRING.2 COUNT-IF-NOT-STRING.3

 COUNT-IF-NOT-STRING.4 COUNT-IF-NOT-STRING.5 COUNT-IF-NOT-STRING.6

 COUNT-IF-NOT-STRING.8 COUNT-IF-NOT-STRING.11 COUNT-IF-NOT-STRING.12

 COUNT-IF-NOT-STRING.13 COUNT-IF-NOT-STRING.14 COUNT-IF-NOT-STRING.15

 COUNT-IF-NOT-STRING.16 COUNT-IF-NOT-STRING.17 COUNT-IF-NOT-STRING.18

 COUNT-IF-NOT.ORDER.1 COUNT-IF-NOT.ORDER.2 COUNT-IF-NOT.KEYWORDS.1

 COUNT-IF-NOT.KEYWORDS.2 COUNT-IF-NOT.KEYWORDS.3 COUNT-IF-NOT.KEYWORDS.4

 COUNT-IF-NOT.ALLOW-OTHER-KEYS.5 COUNT-IF-NOT.ERROR.1

 COUNT-IF-NOT.ERROR.4 COUNT-IF-NOT.ERROR.5 COUNT-IF-NOT.ERROR.6

 COUNT-IF-NOT.ERROR.7 COUNT-IF-NOT.ERROR.8 COUNT-IF-NOT.ERROR.9

 COUNT-IF-NOT.ERROR.10 COUNT-IF-NOT.ERROR.11 COUNT-IF-NOT.ERROR.12

 COUNT-IF-NOT.ERROR.13 COUNT-IF-NOT.ERROR.14 COUNT-IF-NOT.ERROR.15

 REVERSE-LIST.1 REVERSE-LIST.2 REVERSE-VECTOR.1 REVERSE-VECTOR.2

 REVERSE-VECTOR.3 REVERSE-VECTOR.4 REVERSE-VECTOR.5 REVERSE-VECTOR.6

 REVERSE-VECTOR.7 REVERSE-VECTOR.8 REVERSE-VECTOR.9 REVERSE-BIT-VECTOR.1

 REVERSE-BIT-VECTOR.2 REVERSE-BIT-VECTOR.3 REVERSE-STRING.1

 REVERSE-STRING.2 REVERSE-STRING.3 REVERSE-STRING.4 REVERSE-STRING.5

 REVERSE.ORDER.1 REVERSE.FOLD.1 REVERSE.FOLD.2 REVERSE.FOLD.3

 REVERSE.FOLD.4 REVERSE.ERROR.1 REVERSE.ERROR.6 REVERSE.ERROR.7

 REVERSE.ERROR.8 NREVERSE-LIST.1 NREVERSE-LIST.2 NREVERSE-VECTOR.1

 NREVERSE-VECTOR.2 NREVERSE-VECTOR.4 NREVERSE-VECTOR.5 NREVERSE-VECTOR.6

 NREVERSE-VECTOR.7 NREVERSE-VECTOR.8 NREVERSE-VECTOR.9

 NREVERSE-VECTOR.10 NREVERSE-BIT-VECTOR.1 NREVERSE-BIT-VECTOR.2

 NREVERSE-BIT-VECTOR.3 NREVERSE-STRING.1 NREVERSE-STRING.2

 NREVERSE-STRING.3 NREVERSE-STRING.4 NREVERSE-STRING.5 NREVERSE.ORDER.1

 NREVERSE.ERROR.1 NREVERSE.ERROR.6 NREVERSE.ERROR.7 NREVERSE.ERROR.8

 SORT-LIST.1 SORT-LIST.2 SORT-LIST.3 SORT-LIST.4 SORT-VECTOR.1

 SORT-VECTOR.2 SORT-VECTOR.3 SORT-VECTOR.4 SORT-VECTOR.5 SORT-VECTOR.6

 SORT-VECTOR.7 SORT-VECTOR.8 SORT-VECTOR.9 SORT-VECTOR.10

 SORT-BIT-VECTOR.1 SORT-BIT-VECTOR.2 SORT-BIT-VECTOR.3 SORT-STRING.1

 SORT-STRING.2 SORT-STRING.3 SORT-STRING.4 SORT.ORDER.1 SORT.ORDER.2

 SORT.ERROR.1 SORT.ERROR.2 SORT.ERROR.3 SORT.ERROR.4 SORT.ERROR.5

 SORT.ERROR.6 SORT.ERROR.7 SORT.ERROR.8 SORT.ERROR.9 SORT.ERROR.10

 SORT.ERROR.11 STABLE-SORT-LIST.1 STABLE-SORT-LIST.2 STABLE-SORT-LIST.3

 STABLE-SORT-LIST.4 STABLE-SORT-LIST.5 STABLE-SORT-VECTOR.1

 STABLE-SORT-VECTOR.2 STABLE-SORT-VECTOR.3 STABLE-SORT-VECTOR.4

 STABLE-SORT-VECTOR.6 STABLE-SORT-VECTOR.7 STABLE-SORT-VECTOR.8

 STABLE-SORT-VECTOR.9 STABLE-SORT-VECTOR.10 STABLE-SORT-BIT-VECTOR.1

 STABLE-SORT-BIT-VECTOR.2 STABLE-SORT-BIT-VECTOR.3 STABLE-SORT-STRING.1

 STABLE-SORT-STRING.2 STABLE-SORT-STRING.3 STABLE-SORT-STRING.4

 STABLE-SORT.ORDER.1 STABLE-SORT.ORDER.2 STABLE-SORT.ERROR.1

 STABLE-SORT.ERROR.2 STABLE-SORT.ERROR.3 STABLE-SORT.ERROR.4

 STABLE-SORT.ERROR.5 STABLE-SORT.ERROR.6 STABLE-SORT.ERROR.7

 STABLE-SORT.ERROR.8 STABLE-SORT.ERROR.9 STABLE-SORT.ERROR.10

 STABLE-SORT.ERROR.11 LENGTH.LIST.1 LENGTH.LIST.2 LENGTH.LIST.3

 LENGTH.LIST-4 LENGTH.VECTOR.1 LENGTH.VECTOR.2 LENGTH.VECTOR.3

 LENGTH.VECTOR.4 LENGTH.NONSIMPLE-VECTOR.1 LENGTH.NONSIMPLE-VECTOR.2

 LENGTH.BIT-VECTOR.2 LENGTH.BIT-VECTOR.3 LENGTH.BIT-VECTOR.4

 LENGTH.BIT-VECTOR.5 LENGTH.STRING.1 LENGTH.STRING.2 LENGTH.STRING.3

 LENGTH.STRING.4 LENGTH.STRING.5 LENGTH.STRING.6 LENGTH.STRING.7

 LENGTH.STRING.8 LENGTH.ERROR.1 LENGTH.ERROR.6 LENGTH.ERROR.7

 LENGTH.ERROR.8 LENGTH.ARRAY.1 LENGTH.ARRAY.2 LENGTH.ARRAY.3

 LENGTH.ARRAY.4 LENGTH.ARRAY.5 LENGTH.ARRAY.6 LENGTH.ARRAY.7

 LENGTH.ARRAY.8 LENGTH.ARRAY.9 FIND-LIST.1 FIND-LIST.2 FIND-LIST.3

 FIND-LIST.4 FIND-LIST.5 FIND-LIST.6 FIND-LIST.7 FIND-LIST.8 FIND-LIST.9

 FIND-LIST.10 FIND-LIST.11 FIND-LIST.12 FIND-LIST.13 FIND-LIST.14

 FIND-LIST.15 FIND-LIST.16 FIND-LIST.17 FIND-LIST.18 FIND-LIST.19

 FIND-LIST.20 FIND-LIST.21 FIND-LIST.22 FIND-LIST.23 FIND-LIST.24

 FIND-LIST.25 FIND-LIST.26 FIND-LIST.27 FIND-LIST.28 FIND-LIST.29

 FIND-LIST.30 FIND-VECTOR.1 FIND-VECTOR.1A FIND-VECTOR.2 FIND-VECTOR.2A

 FIND-VECTOR.3 FIND-VECTOR.4 FIND-VECTOR.5 FIND-VECTOR.6 FIND-VECTOR.7

 FIND-VECTOR.8 FIND-VECTOR.9 FIND-VECTOR.10 FIND-VECTOR.11

 FIND-VECTOR.12 FIND-VECTOR.13 FIND-VECTOR.14 FIND-VECTOR.15

 FIND-VECTOR.16 FIND-VECTOR.17 FIND-VECTOR.18 FIND-VECTOR.19

 FIND-VECTOR.20 FIND-VECTOR.21 FIND-VECTOR.22 FIND-VECTOR.23

 FIND-VECTOR.24 FIND-VECTOR.25 FIND-VECTOR.26 FIND-VECTOR.27

 FIND-VECTOR.28 FIND-VECTOR.29 FIND-VECTOR.30 FIND-VECTOR.31

 FIND-VECTOR.32 FIND-VECTOR.33 FIND-VECTOR.34 FIND-BIT-VECTOR.1

 FIND-BIT-VECTOR.1A FIND-BIT-VECTOR.1B FIND-BIT-VECTOR.1C

 FIND-BIT-VECTOR.1D FIND-BIT-VECTOR.2 FIND-BIT-VECTOR.2A

 FIND-BIT-VECTOR.2B FIND-BIT-VECTOR.2C FIND-BIT-VECTOR.2D

 FIND-BIT-VECTOR.2E FIND-BIT-VECTOR.3 FIND-BIT-VECTOR.4

 FIND-BIT-VECTOR.5 FIND-BIT-VECTOR.6 FIND-BIT-VECTOR.7 FIND-BIT-VECTOR.8

 FIND-BIT-VECTOR.9 FIND-BIT-VECTOR.10 FIND-BIT-VECTOR.11

 FIND-BIT-VECTOR.12 FIND-BIT-VECTOR.13 FIND-BIT-VECTOR.14

 FIND-BIT-VECTOR.15 FIND-BIT-VECTOR.16 FIND-BIT-VECTOR.16A

 FIND-BIT-VECTOR.16B FIND-BIT-VECTOR.17 FIND-BIT-VECTOR.17A

 FIND-BIT-VECTOR.17B FIND-BIT-VECTOR.18 FIND-BIT-VECTOR.18A

 FIND-BIT-VECTOR.19 FIND-BIT-VECTOR.19A FIND-BIT-VECTOR.20

 FIND-BIT-VECTOR.21 FIND-BIT-VECTOR.21A FIND-BIT-VECTOR.21B

 FIND-BIT-VECTOR.22 FIND-BIT-VECTOR.22A FIND-BIT-VECTOR.22B

 FIND-BIT-VECTOR.23 FIND-BIT-VECTOR.23A FIND-BIT-VECTOR.23B

 FIND-BIT-VECTOR.24 FIND-BIT-VECTOR.24A FIND-BIT-VECTOR.24B

 FIND-BIT-VECTOR.25 FIND-BIT-VECTOR.26 FIND-BIT-VECTOR.26A

 FIND-BIT-VECTOR.27 FIND-BIT-VECTOR.28 FIND-BIT-VECTOR.29

 FIND-BIT-VECTOR.30 FIND-BIT-VECTOR.31 FIND-BIT-VECTOR.32

 FIND-BIT-VECTOR.33 FIND-BIT-VECTOR.34 FIND-STRING.1 FIND-STRING.1A

 FIND-STRING.2 FIND-STRING.2A FIND-STRING.3 FIND-STRING.4 FIND-STRING.5

 FIND-STRING.6 FIND-STRING.7 FIND-STRING.8 FIND-STRING.9 FIND-STRING.10

 FIND-STRING.11 FIND-STRING.13 FIND-STRING.14 FIND-STRING.15

 FIND-STRING.16 FIND-STRING.17 FIND-STRING.18 FIND-STRING.19

 FIND-STRING.20 FIND-STRING.21 FIND-STRING.22 FIND-STRING.23

 FIND-STRING.24 FIND-STRING.25 FIND-STRING.26 FIND-STRING.27

 FIND-STRING.28 FIND-LIST.TEST-AND-TEST-NOT.1

 FIND-LIST.TEST-AND-TEST-NOT.2 FIND-VECTOR.TEST-AND-TEST-NOT.1

 FIND-VECTOR.TEST-AND-TEST-NOT.2 FIND-STRING.TEST-AND-TEST-NOT.1

 FIND-STRING.TEST-AND-TEST-NOT.2 FIND-BIT-STRING.TEST-AND-TEST-NOT.1

 FIND-BIT-STRING.TEST-AND-TEST-NOT.2 FIND.ALLOW-OTHER-KEYS.1

 FIND.ALLOW-OTHER-KEYS.2 FIND.ALLOW-OTHER-KEYS.3 FIND.KEYWORDS.4

 FIND.ALLOW-OTHER-KEYS.5 FIND.ERROR.1 FIND.ERROR.4 FIND.ERROR.5

 FIND.ERROR.6 FIND.ERROR.7 FIND.ERROR.8 FIND.ERROR.9 FIND.ERROR.10

 FIND.ERROR.11 FIND.ERROR.12 FIND.ERROR.13 FIND.ERROR.14 FIND.ERROR.15

 FIND.ORDER.1 FIND.ORDER.2 FIND.ORDER.3 FIND-IF-LIST.1 FIND-IF-LIST.2

 FIND-IF-LIST.2A FIND-IF-LIST.3 FIND-IF-LIST.4 FIND-IF-LIST.5

 FIND-IF-LIST.6 FIND-IF-LIST.7 FIND-IF-LIST.8 FIND-IF-LIST.9

 FIND-IF-LIST.10 FIND-IF-LIST.11 FIND-IF-LIST.12 FIND-IF-LIST.13

 FIND-IF-LIST.14 FIND-IF-LIST.15 FIND-IF-LIST.16 FIND-IF-LIST.17

 FIND-IF-LIST.18 FIND-IF-VECTOR.1 FIND-IF-VECTOR.2 FIND-IF-VECTOR.2A

 FIND-IF-VECTOR.3 FIND-IF-VECTOR.4 FIND-IF-VECTOR.5 FIND-IF-VECTOR.6

 FIND-IF-VECTOR.7 FIND-IF-VECTOR.8 FIND-IF-VECTOR.9 FIND-IF-VECTOR.10

 FIND-IF-VECTOR.11 FIND-IF-VECTOR.12 FIND-IF-VECTOR.13 FIND-IF-VECTOR.14

 FIND-IF-VECTOR.15 FIND-IF-VECTOR.16 FIND-IF-VECTOR.17 FIND-IF-VECTOR.18

 FIND-IF-VECTOR.19 FIND-IF-BIT-VECTOR.1 FIND-IF-BIT-VECTOR.2

 FIND-IF-BIT-VECTOR.3 FIND-IF-BIT-VECTOR.4 FIND-IF-BIT-VECTOR.5

 FIND-IF-BIT-VECTOR.6 FIND-IF-BIT-VECTOR.7 FIND-IF-STRING.1

 FIND-IF-STRING.2 FIND-IF-STRING.2A FIND-IF-STRING.3 FIND-IF-STRING.3A

 FIND-IF-STRING.4 FIND-IF-STRING.5 FIND-IF-STRING.6 FIND-IF-STRING.7

 FIND-IF-STRING.8 FIND-IF-STRING.9 FIND-IF-STRING.10 FIND-IF-STRING.11

 FIND-IF-STRING.12 FIND-IF-STRING.13 FIND-IF-STRING.14 FIND-IF-STRING.15

 FIND-IF-STRING.16 FIND-IF-STRING.17 FIND-IF-STRING.18 FIND-IF-STRING.19

 FIND-IF-STRING.20 FIND-IF.ALLOW-OTHER-KEYS.1 FIND-IF.ALLOW-OTHER-KEYS.2

 FIND-IF.ALLOW-OTHER-KEYS.3 FIND-IF.KEYWORDS.4

 FIND-IF.ALLOW-OTHER-KEYS.5 FIND-IF.ERROR.1 FIND-IF.ERROR.4

 FIND-IF.ERROR.5 FIND-IF.ERROR.6 FIND-IF.ERROR.7 FIND-IF.ERROR.8

 FIND-IF.ERROR.9 FIND-IF.ERROR.10 FIND-IF.ERROR.11 FIND-IF.ERROR.12

 FIND-IF.ERROR.13 FIND-IF.ERROR.14 FIND-IF.ERROR.15 FIND-IF.ORDER.1

 FIND-IF.ORDER.2 FIND-IF.ORDER.3 FIND-IF-NOT-LIST.1 FIND-IF-NOT-LIST.2

 FIND-IF-NOT-LIST.2A FIND-IF-NOT-LIST.3 FIND-IF-NOT-LIST.4

 FIND-IF-NOT-LIST.5 FIND-IF-NOT-LIST.6 FIND-IF-NOT-LIST.7

 FIND-IF-NOT-LIST.8 FIND-IF-NOT-LIST.9 FIND-IF-NOT-LIST.10

 FIND-IF-NOT-LIST.11 FIND-IF-NOT-LIST.12 FIND-IF-NOT-LIST.13

 FIND-IF-NOT-LIST.14 FIND-IF-NOT-LIST.15 FIND-IF-NOT-LIST.16

 FIND-IF-NOT-LIST.17 FIND-IF-NOT-LIST.18 FIND-IF-NOT-VECTOR.1

 FIND-IF-NOT-VECTOR.2 FIND-IF-NOT-VECTOR.2A FIND-IF-NOT-VECTOR.3

 FIND-IF-NOT-VECTOR.4 FIND-IF-NOT-VECTOR.5 FIND-IF-NOT-VECTOR.6

 FIND-IF-NOT-VECTOR.7 FIND-IF-NOT-VECTOR.8 FIND-IF-NOT-VECTOR.9

 FIND-IF-NOT-VECTOR.10 FIND-IF-NOT-VECTOR.11 FIND-IF-NOT-VECTOR.12

 FIND-IF-NOT-VECTOR.13 FIND-IF-NOT-VECTOR.14 FIND-IF-NOT-VECTOR.15

 FIND-IF-NOT-VECTOR.16 FIND-IF-NOT-VECTOR.17 FIND-IF-NOT-VECTOR.18

 FIND-IF-NOT-BIT-VECTOR.1 FIND-IF-NOT-BIT-VECTOR.2

 FIND-IF-NOT-BIT-VECTOR.3 FIND-IF-NOT-BIT-VECTOR.4

 FIND-IF-NOT-BIT-VECTOR.5 FIND-IF-NOT-BIT-VECTOR.6

 FIND-IF-NOT-BIT-VECTOR.7 FIND-IF-NOT-STRING.1 FIND-IF-NOT-STRING.2

 FIND-IF-NOT-STRING.2A FIND-IF-NOT-STRING.3 FIND-IF-NOT-STRING.3A

 FIND-IF-NOT-STRING.4 FIND-IF-NOT-STRING.5 FIND-IF-NOT-STRING.6

 FIND-IF-NOT-STRING.7 FIND-IF-NOT-STRING.8 FIND-IF-NOT-STRING.9

 FIND-IF-NOT-STRING.10 FIND-IF-NOT-STRING.11 FIND-IF-NOT-STRING.12

 FIND-IF-NOT-STRING.13 FIND-IF-NOT-STRING.14 FIND-IF-NOT-STRING.15

 FIND-IF-NOT-STRING.16 FIND-IF-NOT-STRING.17 FIND-IF-NOT-STRING.18

 FIND-IF-NOT-STRING.19 FIND-IF-NOT.ALLOW-OTHER-KEYS.1

 FIND-IF-NOT.ALLOW-OTHER-KEYS.2 FIND-IF-NOT.ALLOW-OTHER-KEYS.3

 FIND-IF-NOT.KEYWORDS.4 FIND-IF-NOT.ALLOW-OTHER-KEYS.5

 FIND-IF-NOT.ERROR.1 FIND-IF-NOT.ERROR.4 FIND-IF-NOT.ERROR.5

 FIND-IF-NOT.ERROR.6 FIND-IF-NOT.ERROR.7 FIND-IF-NOT.ERROR.8

 FIND-IF-NOT.ERROR.9 FIND-IF-NOT.ERROR.10 FIND-IF-NOT.ERROR.11

 FIND-IF-NOT.ERROR.12 FIND-IF-NOT.ERROR.13 FIND-IF-NOT.ERROR.14

 FIND-IF-NOT.ERROR.15 FIND-IF-NOT.ORDER.1 FIND-IF-NOT.ORDER.2

 FIND-IF-NOT.ORDER.3 POSITION-LIST.1 POSITION-LIST.2 POSITION-LIST.3

 POSITION-LIST.4 POSITION-LIST.5 POSITION-LIST.6 POSITION-LIST.7

 POSITION-LIST.8 POSITION-LIST.9 POSITION-LIST.10 POSITION-LIST.11

 POSITION-LIST.12 POSITION-LIST.13 POSITION-LIST.14 POSITION-LIST.15

 POSITION-LIST.16 POSITION-LIST.17 POSITION-LIST.18 POSITION-LIST.19

 POSITION-LIST.20 POSITION-LIST.21 POSITION-LIST.22 POSITION-LIST.23

 POSITION-LIST.24 POSITION-LIST.25 POSITION-LIST.26 POSITION-LIST.27

 POSITION-LIST.28 POSITION-LIST.29 POSITION-LIST.30 POSITION-VECTOR.1

 POSITION-VECTOR.2 POSITION-VECTOR.3 POSITION-VECTOR.4 POSITION-VECTOR.5

 POSITION-VECTOR.6 POSITION-VECTOR.7 POSITION-VECTOR.8 POSITION-VECTOR.9

 POSITION-VECTOR.10 POSITION-VECTOR.11 POSITION-VECTOR.12

 POSITION-VECTOR.13 POSITION-VECTOR.14 POSITION-VECTOR.15

 POSITION-VECTOR.16 POSITION-VECTOR.17 POSITION-VECTOR.18

 POSITION-VECTOR.19 POSITION-VECTOR.20 POSITION-VECTOR.21

 POSITION-VECTOR.22 POSITION-VECTOR.23 POSITION-VECTOR.24

 POSITION-VECTOR.25 POSITION-VECTOR.26 POSITION-VECTOR.27

 POSITION-VECTOR.28 POSITION-VECTOR.29 POSITION-VECTOR.30

 POSITION-VECTOR.31 POSITION-VECTOR.32 POSITION-VECTOR.33

 POSITION-VECTOR.34 POSITION-BIT-VECTOR.1 POSITION-BIT-VECTOR.2

 POSITION-BIT-VECTOR.3 POSITION-BIT-VECTOR.4 POSITION-BIT-VECTOR.5

 POSITION-BIT-VECTOR.6 POSITION-BIT-VECTOR.7 POSITION-BIT-VECTOR.8

 POSITION-BIT-VECTOR.9 POSITION-BIT-VECTOR.10 POSITION-BIT-VECTOR.11

 POSITION-BIT-VECTOR.12 POSITION-BIT-VECTOR.13 POSITION-BIT-VECTOR.14

 POSITION-BIT-VECTOR.15 POSITION-BIT-VECTOR.16 POSITION-BIT-VECTOR.17

 POSITION-BIT-VECTOR.18 POSITION-BIT-VECTOR.19 POSITION-BIT-VECTOR.20

 POSITION-BIT-VECTOR.21 POSITION-BIT-VECTOR.22 POSITION-BIT-VECTOR.23

 POSITION-BIT-VECTOR.24 POSITION-BIT-VECTOR.25 POSITION-BIT-VECTOR.27

 POSITION-BIT-VECTOR.28 POSITION-BIT-VECTOR.29 POSITION-BIT-VECTOR.30

 POSITION-BIT-VECTOR.31 POSITION-BIT-VECTOR.32 POSITION-BIT-VECTOR.33

 POSITION-BIT-VECTOR.34 POSITION-STRING.1 POSITION-STRING.2

 POSITION-STRING.3 POSITION-STRING.4 POSITION-STRING.5 POSITION-STRING.6

 POSITION-STRING.7 POSITION-STRING.8 POSITION-STRING.9

 POSITION-STRING.10 POSITION-STRING.11 POSITION-STRING.13

 POSITION-STRING.14 POSITION-STRING.15 POSITION-STRING.16

 POSITION-STRING.17 POSITION-STRING.18 POSITION-STRING.19

 POSITION-STRING.20 POSITION-STRING.21 POSITION-STRING.22

 POSITION-STRING.23 POSITION-STRING.24 POSITION-STRING.25

 POSITION-STRING.26 POSITION-STRING.27 POSITION-STRING.28

 POSITION-STRING.29 POSITION-STRING.30 POSITION-STRING.31

 POSITION-STRING.32 POSITION-STRING.33 POSITION-STRING.34

 POSITION.TEST-AND-TEST-NOT.1 POSITION.TEST-AND-TEST-NOT.2

 POSITION.TEST-AND-TEST-NOT.3 POSITION.TEST-AND-TEST-NOT.4

 POSITION.TEST-AND-TEST-NOT.5 POSITION.TEST-AND-TEST-NOT.6

 POSITION.TEST-AND-TEST-NOT.7 POSITION.TEST-AND-TEST-NOT.8

 POSITION.ORDER.1 POSITION.ORDER.2 POSITION.ALLOW-OTHER-KEYS.1

 POSITION.ALLOW-OTHER-KEYS.2 POSITION.ALLOW-OTHER-KEYS.3

 POSITION.ALLOW-OTHER-KEYS.4 POSITION.ALLOW-OTHER-KEYS.5

 POSITION.KEYWORDS.6 POSITION.ALLOW-OTHER-KEYS.7

 POSITION.ALLOW-OTHER-KEYS.8 POSITION.ALLOW-OTHER-KEYS.9

 POSITION.ERROR.1 POSITION.ERROR.4 POSITION.ERROR.5 POSITION.ERROR.6

 POSITION.ERROR.7 POSITION.ERROR.8 POSITION.ERROR.9 POSITION.ERROR.10

 POSITION.ERROR.11 POSITION.ERROR.12 POSITION.ERROR.13 POSITION.ERROR.14

 POSITION.ERROR.15 POSITION-IF-LIST.1 POSITION-IF-LIST.2

 POSITION-IF-LIST.3 POSITION-IF-LIST.4 POSITION-IF-LIST.5

 POSITION-IF-LIST.6 POSITION-IF-LIST.7 POSITION-IF-LIST.8

 POSITION-IF-LIST.9 POSITION-IF-LIST.10 POSITION-IF-LIST.11

 POSITION-IF-LIST.12 POSITION-IF-VECTOR.1 POSITION-IF-VECTOR.2

 POSITION-IF-VECTOR.3 POSITION-IF-VECTOR.4 POSITION-IF-VECTOR.5

 POSITION-IF-VECTOR.6 POSITION-IF-VECTOR.7 POSITION-IF-VECTOR.8

 POSITION-IF-VECTOR.9 POSITION-IF-VECTOR.10 POSITION-IF-VECTOR.11

 POSITION-IF-VECTOR.12 POSITION-IF-VECTOR.13 POSITION-IF-VECTOR.14

 POSITION-IF-BIT-VECTOR.1 POSITION-IF-BIT-VECTOR.2

 POSITION-IF-BIT-VECTOR.3 POSITION-IF-BIT-VECTOR.4

 POSITION-IF-BIT-VECTOR.5 POSITION-IF-BIT-VECTOR.6

 POSITION-IF-BIT-VECTOR.7 POSITION-IF-BIT-VECTOR.8

 POSITION-IF-BIT-VECTOR.9 POSITION-IF-BIT-VECTOR.10

 POSITION-IF-BIT-VECTOR.11 POSITION-IF-BIT-VECTOR.12

 POSITION-IF-BIT-VECTOR.13 POSITION-IF-STRING.1 POSITION-IF-STRING.2

 POSITION-IF-STRING.3 POSITION-IF-STRING.4 POSITION-IF-STRING.5

 POSITION-IF-STRING.6 POSITION-IF-STRING.7 POSITION-IF-STRING.8

 POSITION-IF-STRING.9 POSITION-IF-STRING.10 POSITION-IF-STRING.11

 POSITION-IF-STRING.12 POSITION-IF-STRING.13 POSITION-IF-STRING.14

 POSITION-IF-STRING.15 POSITION-IF.ORDER.1 POSITION-IF.ORDER.2

 POSITION-IF.ALLOW-OTHER-KEYS.1 POSITION-IF.ALLOW-OTHER-KEYS.2

 POSITION-IF.ALLOW-OTHER-KEYS.3 POSITION-IF.ALLOW-OTHER-KEYS.4

 POSITION-IF.ALLOW-OTHER-KEYS.5 POSITION-IF.KEYWORDS.6

 POSITION-IF.ALLOW-OTHER-KEYS.7 POSITION-IF.ALLOW-OTHER-KEYS.8

 POSITION-IF.ALLOW-OTHER-KEYS.9 POSITION-IF.ERROR.1 POSITION-IF.ERROR.4

 POSITION-IF.ERROR.5 POSITION-IF.ERROR.6 POSITION-IF.ERROR.7

 POSITION-IF.ERROR.8 POSITION-IF.ERROR.9 POSITION-IF.ERROR.10

 POSITION-IF.ERROR.11 POSITION-IF.ERROR.12 POSITION-IF.ERROR.13

 POSITION-IF.ERROR.14 POSITION-IF.ERROR.15 POSITION-IF-NOT-LIST.1

 POSITION-IF-NOT-LIST.2 POSITION-IF-NOT-LIST.3 POSITION-IF-NOT-LIST.4

 POSITION-IF-NOT-LIST.5 POSITION-IF-NOT-LIST.6 POSITION-IF-NOT-LIST.7

 POSITION-IF-NOT-LIST.8 POSITION-IF-NOT-LIST.9 POSITION-IF-NOT-LIST.10

 POSITION-IF-NOT-LIST.11 POSITION-IF-NOT-LIST.12

 POSITION-IF-NOT-VECTOR.1 POSITION-IF-NOT-VECTOR.2

 POSITION-IF-NOT-VECTOR.3 POSITION-IF-NOT-VECTOR.4

 POSITION-IF-NOT-VECTOR.5 POSITION-IF-NOT-VECTOR.6

 POSITION-IF-NOT-VECTOR.7 POSITION-IF-NOT-VECTOR.8

 POSITION-IF-NOT-VECTOR.9 POSITION-IF-NOT-VECTOR.10

 POSITION-IF-NOT-VECTOR.11 POSITION-IF-NOT-VECTOR.12

 POSITION-IF-NOT-VECTOR.13 POSITION-IF-NOT-VECTOR.14

 POSITION-IF-NOT-BIT-VECTOR.1 POSITION-IF-NOT-BIT-VECTOR.2

 POSITION-IF-NOT-BIT-VECTOR.3 POSITION-IF-NOT-BIT-VECTOR.4

 POSITION-IF-NOT-BIT-VECTOR.5 POSITION-IF-NOT-BIT-VECTOR.6

 POSITION-IF-NOT-BIT-VECTOR.7 POSITION-IF-NOT-BIT-VECTOR.8

 POSITION-IF-NOT-BIT-VECTOR.9 POSITION-IF-NOT-BIT-VECTOR.10

 POSITION-IF-NOT-BIT-VECTOR.11 POSITION-IF-NOT-BIT-VECTOR.12

 POSITION-IF-NOT-BIT-VECTOR.13 POSITION-IF-NOT-STRING.1

 POSITION-IF-NOT-STRING.2 POSITION-IF-NOT-STRING.3

 POSITION-IF-NOT-STRING.4 POSITION-IF-NOT-STRING.5

 POSITION-IF-NOT-STRING.6 POSITION-IF-NOT-STRING.7

 POSITION-IF-NOT-STRING.8 POSITION-IF-NOT-STRING.9

 POSITION-IF-NOT-STRING.10 POSITION-IF-NOT-STRING.11

 POSITION-IF-NOT-STRING.12 POSITION-IF-NOT-STRING.13

 POSITION-IF-NOT-STRING.14 POSITION-IF-NOT-STRING.15

 POSITION-IF-NOT.ORDER.1 POSITION-IF-NOT.ORDER.2

 POSITION-IF-NOT.ALLOW-OTHER-KEYS.1 POSITION-IF-NOT.ALLOW-OTHER-KEYS.2

 POSITION-IF-NOT.ALLOW-OTHER-KEYS.3 POSITION-IF-NOT.ALLOW-OTHER-KEYS.4

 POSITION-IF-NOT.ALLOW-OTHER-KEYS.5 POSITION-IF-NOT.KEYWORDS.6

 POSITION-IF-NOT.ALLOW-OTHER-KEYS.7 POSITION-IF-NOT.ALLOW-OTHER-KEYS.8

 POSITION-IF-NOT.ALLOW-OTHER-KEYS.9 POSITION-IF-NOT.ERROR.1

 POSITION-IF-NOT.ERROR.4 POSITION-IF-NOT.ERROR.5 POSITION-IF-NOT.ERROR.6

 POSITION-IF-NOT.ERROR.7 POSITION-IF-NOT.ERROR.8 POSITION-IF-NOT.ERROR.9

 POSITION-IF-NOT.ERROR.10 POSITION-IF-NOT.ERROR.11

 POSITION-IF-NOT.ERROR.12 POSITION-IF-NOT.ERROR.13

 POSITION-IF-NOT.ERROR.14 POSITION-IF-NOT.ERROR.15 SEARCH-LIST.1

 SEARCH-LIST.2 SEARCH-LIST.3 SEARCH-LIST.4 SEARCH-LIST.5 SEARCH-LIST.6

 SEARCH-LIST.7 SEARCH-LIST.8 SEARCH-LIST.9 SEARCH-LIST.10 SEARCH-LIST.11

 SEARCH-LIST.12 SEARCH-LIST.13 SEARCH-LIST.14 SEARCH-LIST.15

 SEARCH-LIST.16 SEARCH.TEST-AND-TEST-NOT.1 SEARCH.TEST-AND-TEST-NOT.2

 SEARCH.TEST-AND-TEST-NOT.3 SEARCH.TEST-AND-TEST-NOT.4

 SEARCH.TEST-AND-TEST-NOT.5 SEARCH.TEST-AND-TEST-NOT.6

 SEARCH.TEST-AND-TEST-NOT.7 SEARCH.TEST-AND-TEST-NOT.8

 SEARCH.ALLOW-OTHER-KEYS.1 SEARCH.ALLOW-OTHER-KEYS.2

 SEARCH.ALLOW-OTHER-KEYS.3 SEARCH.ALLOW-OTHER-KEYS.4

 SEARCH.ALLOW-OTHER-KEYS.5 SEARCH.ALLOW-OTHER-KEYS.6

 SEARCH.ALLOW-OTHER-KEYS.7 SEARCH.KEYWORDS.8 SEARCH.ERROR.1

 SEARCH.ERROR.2 SEARCH.ERROR.3 SEARCH.ERROR.4 SEARCH.ERROR.5

 SEARCH.ERROR.6 SEARCH.ERROR.7 SEARCH.ERROR.8 SEARCH.ERROR.9

 SEARCH.ERROR.10 SEARCH.ORDER.1 SEARCH.ORDER.2 SEARCH-VECTOR.1

 SEARCH-VECTOR.2 SEARCH-VECTOR.3 SEARCH-VECTOR.4 SEARCH-VECTOR.5

 SEARCH-VECTOR.6 SEARCH-VECTOR.7 SEARCH-VECTOR.8 SEARCH-VECTOR.9

 SEARCH-VECTOR.10 SEARCH-VECTOR.11 SEARCH-VECTOR.12 SEARCH-VECTOR.13

 SEARCH-VECTOR.14 SEARCH-VECTOR.15 SEARCH-VECTOR.16 SEARCH-VECTOR.17

 SEARCH-VECTOR.18 SEARCH-BITVECTOR.1 SEARCH-BITVECTOR.2

 SEARCH-BITVECTOR.3 SEARCH-BITVECTOR.4 SEARCH-BITVECTOR.5

 SEARCH-BITVECTOR.6 SEARCH-BITVECTOR.7 SEARCH-BITVECTOR.8

 SEARCH-BITVECTOR.9 SEARCH-BITVECTOR.10 SEARCH-BITVECTOR.11

 SEARCH-BITVECTOR.12 SEARCH-BITVECTOR.13 SEARCH-BITVECTOR.14

 SEARCH-BITVECTOR.15 SEARCH-BITVECTOR.16 SEARCH-BITVECTOR.17

 SEARCH-BITVECTOR.18 SEARCH-STRING.2 SEARCH-STRING.3 SEARCH-STRING.4

 SEARCH-STRING.5 SEARCH-STRING.6 SEARCH-STRING.7 SEARCH-STRING.8

 SEARCH-STRING.9 SEARCH-STRING.10 SEARCH-STRING.11 SEARCH-STRING.13

 SEARCH-STRING.14 SEARCH-STRING.15 SEARCH-STRING.16 SEARCH-STRING.17

 SEARCH-STRING.18 SEARCH-STRING.19 SEARCH-STRING.20 MISMATCH-LIST.1

 MISMATCH-LIST.2 MISMATCH-LIST.3 MISMATCH-LIST.4 MISMATCH-LIST.5

 MISMATCH-LIST.6 MISMATCH-LIST.7 MISMATCH-LIST.8 MISMATCH-LIST.9

 MISMATCH-LIST.10 MISMATCH-LIST.11 MISMATCH-LIST.12 MISMATCH-LIST.13

 MISMATCH-LIST.14 MISMATCH-LIST.15 MISMATCH-LIST.16 MISMATCH-LIST.17

 MISMATCH-LIST.18 MISMATCH-LIST.19 MISMATCH-LIST.20 MISMATCH-LIST.21

 MISMATCH-LIST.22 MISMATCH-VECTOR.1 MISMATCH-VECTOR.2 MISMATCH-VECTOR.3

 MISMATCH-VECTOR.4 MISMATCH-VECTOR.5 MISMATCH-VECTOR.6 MISMATCH-VECTOR.7

 MISMATCH-VECTOR.8 MISMATCH-VECTOR.9 MISMATCH-VECTOR.10

 MISMATCH-VECTOR.11 MISMATCH-VECTOR.12 MISMATCH-VECTOR.13

 MISMATCH-VECTOR.14 MISMATCH-VECTOR.15 MISMATCH-VECTOR.16

 MISMATCH-VECTOR.17 MISMATCH-VECTOR.18 MISMATCH-VECTOR.19

 MISMATCH-VECTOR.20 MISMATCH-VECTOR.21 MISMATCH-VECTOR.22

 MISMATCH-VECTOR.23 MISMATCH-VECTOR.24 MISMATCH-BIT-VECTOR.1

 MISMATCH-BIT-VECTOR.1A MISMATCH-BIT-VECTOR.1B MISMATCH-BIT-VECTOR.2

 MISMATCH-BIT-VECTOR.2A MISMATCH-BIT-VECTOR.2B MISMATCH-BIT-VECTOR.3

 MISMATCH-BIT-VECTOR.4 MISMATCH-BIT-VECTOR.5 MISMATCH-BIT-VECTOR.6

 MISMATCH-BIT-VECTOR.7 MISMATCH-BIT-VECTOR.7A MISMATCH-BIT-VECTOR.7B

 MISMATCH-BIT-VECTOR.8 MISMATCH-BIT-VECTOR.8A MISMATCH-BIT-VECTOR.9

 MISMATCH-BIT-VECTOR.9A MISMATCH-BIT-VECTOR.9B MISMATCH-BIT-VECTOR.10

 MISMATCH-BIT-VECTOR.10A MISMATCH-BIT-VECTOR.11 MISMATCH-BIT-VECTOR.11A

 MISMATCH-BIT-VECTOR.11B MISMATCH-BIT-VECTOR.11C MISMATCH-BIT-VECTOR.11D

 MISMATCH-BIT-VECTOR.12 MISMATCH-BIT-VECTOR.12A MISMATCH-BIT-VECTOR.12B

 MISMATCH-BIT-VECTOR.13 MISMATCH-BIT-VECTOR.14 MISMATCH-BIT-VECTOR.15

 MISMATCH-BIT-VECTOR.16 MISMATCH-BIT-VECTOR.17 MISMATCH-BIT-VECTOR.18

 MISMATCH-BIT-VECTOR.19 MISMATCH-BIT-VECTOR.20 MISMATCH-BIT-VECTOR.21

 MISMATCH-BIT-VECTOR.22 MISMATCH-BIT-VECTOR.23 MISMATCH-BIT-VECTOR.24

 MISMATCH-STRING.1 MISMATCH-STRING.1A MISMATCH-STRING.1B

 MISMATCH-STRING.2 MISMATCH-STRING.2A MISMATCH-STRING.2B

 MISMATCH-STRING.3 MISMATCH-STRING.4 MISMATCH-STRING.5 MISMATCH-STRING.6

 MISMATCH-STRING.7 MISMATCH-STRING.7A MISMATCH-STRING.7B

 MISMATCH-STRING.8 MISMATCH-STRING.8A MISMATCH-STRING.9

 MISMATCH-STRING.9A MISMATCH-STRING.9B MISMATCH-STRING.10

 MISMATCH-STRING.10A MISMATCH-STRING.11 MISMATCH-STRING.11A

 MISMATCH-STRING.11B MISMATCH-STRING.11C MISMATCH-STRING.11D

 MISMATCH-STRING.11E MISMATCH-STRING.12 MISMATCH-STRING.12A

 MISMATCH-STRING.12B MISMATCH-STRING.13 MISMATCH-STRING.14

 MISMATCH-STRING.15 MISMATCH-STRING.16 MISMATCH-STRING.17

 MISMATCH-STRING.18 MISMATCH-STRING.19 MISMATCH-STRING.20

 MISMATCH-STRING.20A MISMATCH-STRING.21 MISMATCH-STRING.22

 MISMATCH-STRING.23 MISMATCH-STRING.24 MISTMATCH-STRING.25

 MISMATCH.TEST-AND-TEST-NOT.1 MISMATCH.TEST-AND-TEST-NOT.2

 MISMATCH.TEST-AND-TEST-NOT.3 MISMATCH.TEST-AND-TEST-NOT.4

 MISMATCH.TEST-AND-TEST-NOT.5 MISMATCH.TEST-AND-TEST-NOT.6

 MISMATCH.TEST-AND-TEST-NOT.7 MISMATCH.TEST-AND-TEST-NOT.8

 MISMATCH.ALLOW-OTHER-KEYS.1 MISMATCH.ALLOW-OTHER-KEYS.2

 MISMATCH.ALLOW-OTHER-KEYS.3 MISMATCH.ALLOW-OTHER-KEYS.4

 MISMATCH.ALLOW-OTHER-KEYS.5 MISMATCH.KEYWORDS.6

 MISMATCH.ALLOW-OTHER-KEYS.7 MISMATCH.ORDER.1 MISMATCH.ORDER.2

 MISMATCH.ORDER.3 MISMATCH.ERROR.1 MISMATCH.ERROR.2 MISMATCH.ERROR.3

 MISMATCH.ERROR.4 MISMATCH.ERROR.5 MISMATCH.ERROR.6 MISMATCH.ERROR.7

 MISMATCH.ERROR.8 MISMATCH.ERROR.9 MISMATCH.ERROR.10 REPLACE-LIST.1

 REPLACE-LIST.2 REPLACE-LIST.3 REPLACE-LIST.4 REPLACE-LIST.5

 REPLACE-LIST.6 REPLACE-LIST.7 REPLACE-LIST.8 REPLACE-LIST.9

 REPLACE-LIST.10 REPLACE-LIST.11 REPLACE-LIST.12 REPLACE-LIST.13

 REPLACE-LIST.14 REPLACE-LIST.15 REPLACE-LIST.16 REPLACE-LIST.17

 REPLACE-LIST.18 REPLACE-LIST.19 REPLACE-LIST.20 REPLACE-VECTOR.1

 REPLACE-VECTOR.2 REPLACE-VECTOR.3 REPLACE-VECTOR.4 REPLACE-VECTOR.5

 REPLACE-VECTOR.6 REPLACE-VECTOR.7 REPLACE-VECTOR.8 REPLACE-VECTOR.9

 REPLACE-VECTOR.10 REPLACE-VECTOR.11 REPLACE-VECTOR.12 REPLACE-VECTOR.13

 REPLACE-VECTOR.14 REPLACE-VECTOR.15 REPLACE-VECTOR.16 REPLACE-VECTOR.17

 REPLACE-VECTOR.18 REPLACE-VECTOR.19 REPLACE-VECTOR.21

 REPLACE-BIT-VECTOR.1 REPLACE-BIT-VECTOR.2 REPLACE-BIT-VECTOR.3

 REPLACE-BIT-VECTOR.4 REPLACE-BIT-VECTOR.5 REPLACE-BIT-VECTOR.6

 REPLACE-BIT-VECTOR.7 REPLACE-BIT-VECTOR.8 REPLACE-BIT-VECTOR.9

 REPLACE-BIT-VECTOR.10 REPLACE-BIT-VECTOR.11 REPLACE-BIT-VECTOR.12

 REPLACE-BIT-VECTOR.13 REPLACE-BIT-VECTOR.14 REPLACE-BIT-VECTOR.15

 REPLACE-BIT-VECTOR.16 REPLACE-BIT-VECTOR.17 REPLACE-BIT-VECTOR.18

 REPLACE-BIT-VECTOR.19 REPLACE-BIT-VECTOR.21 REPLACE-STRING.1

 REPLACE-STRING.2 REPLACE-STRING.3 REPLACE-STRING.4 REPLACE-STRING.5

 REPLACE-STRING.6 REPLACE-STRING.7 REPLACE-STRING.8 REPLACE-STRING.9

 REPLACE-STRING.10 REPLACE-STRING.11 REPLACE-STRING.12 REPLACE-STRING.13

 REPLACE-STRING.14 REPLACE-STRING.15 REPLACE-STRING.16 REPLACE-STRING.17

 REPLACE-STRING.18 REPLACE-STRING.19 REPLACE-STRING.21 REPLACE-STRING.22

 REPLACE-STRING.23 REPLACE-STRING.24 REPLACE-STRING.25 REPLACE-STRING.26

 REPLACE.ORDER.1 REPLACE.ORDER.2 REPLACE.ORDER.3

 REPLACE.ALLOW-OTHER-KEYS.1 REPLACE.ALLOW-OTHER-KEYS.2

 REPLACE.ALLOW-OTHER-KEYS.3 REPLACE.ALLOW-OTHER-KEYS.4

 REPLACE.ALLOW-OTHER-KEYS.5 REPLACE.ALLOW-OTHER-KEYS.6

 REPLACE.KEYWORDS.7 REPLACE.ERROR.1 REPLACE.ERROR.2 REPLACE.ERROR.3

 REPLACE.ERROR.4 REPLACE.ERROR.5 REPLACE.ERROR.6 SUBSEQ-LIST.1

 SUBSEQ-LIST.2 SUBSEQ-LIST.3 SUBSEQ-LIST.4 SUBSEQ-LIST.5 SUBSEQ-LIST.6

 SUBSEQ-LIST.7 SUBSEQ-LIST.8 SUBSEQ-LIST.9 SUBSEQ-LIST.10 SUBSEQ-LIST.11

 SUBSEQ-LIST.12 SUBSEQ-VECTOR.1 SUBSEQ-VECTOR.2 SUBSEQ-VECTOR.3

 SUBSEQ-VECTOR.4 SUBSEQ-VECTOR.5 SUBSEQ-VECTOR.6 SUBSEQ-VECTOR.7

 SUBSEQ-VECTOR.8 SUBSEQ-VECTOR.9 SUBSEQ-VECTOR.10 SUBSEQ-STRING.1

 SUBSEQ-STRING.2 SUBSEQ-STRING.3 SUBSEQ.SPECIALIZED-STRING.1

 SUBSEQ.SPECIALIZED-VECTOR.1 SUBSEQ.SPECIALIZED-VECTOR.2

 SUBSEQ.SPECIALIZED-VECTOR.3 SUBSEQ-BIT-VECTOR.1 SUBSEQ-BIT-VECTOR.2

 SUBSEQ-BIT-VECTOR.3 SUBSEQ.ORDER.1 SUBSEQ.ORDER.2 SUBSEQ.ORDER.3

 SUBSEQ.ORDER.4 SUBSEQ.FOLD.1 SUBSEQ.FOLD.2 SUBSEQ.FOLD.3 SUBSEQ.FOLD.4

 SUBSEQ.ERROR.1 SUBSEQ.ERROR.2 SUBSEQ.ERROR.3 SUBSTITUTE-LIST.1

 SUBSTITUTE-LIST.2 SUBSTITUTE-LIST.3 SUBSTITUTE-LIST.4 SUBSTITUTE-LIST.5

 SUBSTITUTE-LIST.6 SUBSTITUTE-LIST.7 SUBSTITUTE-LIST.8 SUBSTITUTE-LIST.9

 SUBSTITUTE-LIST.10 SUBSTITUTE-LIST.11 SUBSTITUTE-LIST.12

 SUBSTITUTE-LIST.13 SUBSTITUTE-LIST.14 SUBSTITUTE-LIST.15

 SUBSTITUTE-LIST.16 SUBSTITUTE-LIST.17 SUBSTITUTE-LIST.18

 SUBSTITUTE-LIST.19 SUBSTITUTE-LIST.20 SUBSTITUTE-LIST.21

 SUBSTITUTE-LIST.22 SUBSTITUTE-LIST.23 SUBSTITUTE-LIST.24

 SUBSTITUTE-LIST.25 SUBSTITUTE-LIST.26 SUBSTITUTE-LIST.27

 SUBSTITUTE-VECTOR.1 SUBSTITUTE-VECTOR.2 SUBSTITUTE-VECTOR.3

 SUBSTITUTE-VECTOR.4 SUBSTITUTE-VECTOR.5 SUBSTITUTE-VECTOR.6

 SUBSTITUTE-VECTOR.7 SUBSTITUTE-VECTOR.8 SUBSTITUTE-VECTOR.9

 SUBSTITUTE-VECTOR.10 SUBSTITUTE-VECTOR.11 SUBSTITUTE-VECTOR.12

 SUBSTITUTE-VECTOR.13 SUBSTITUTE-VECTOR.14 SUBSTITUTE-VECTOR.15

 SUBSTITUTE-VECTOR.16 SUBSTITUTE-VECTOR.17 SUBSTITUTE-VECTOR.18

 SUBSTITUTE-VECTOR.19 SUBSTITUTE-VECTOR.20 SUBSTITUTE-VECTOR.21

 SUBSTITUTE-VECTOR.22 SUBSTITUTE-VECTOR.23 SUBSTITUTE-VECTOR.24

 SUBSTITUTE-VECTOR.25 SUBSTITUTE-VECTOR.26 SUBSTITUTE-VECTOR.27

 SUBSTITUTE-VECTOR.28 SUBSTITUTE-VECTOR.29 SUBSTITUTE-VECTOR.30

 SUBSTITUTE-VECTOR.31 SUBSTITUTE-VECTOR.32 SUBSTITUTE-VECTOR.33

 SUBSTITUTE-STRING.1 SUBSTITUTE-STRING.2 SUBSTITUTE-STRING.3

 SUBSTITUTE-STRING.4 SUBSTITUTE-STRING.5 SUBSTITUTE-STRING.6

 SUBSTITUTE-STRING.7 SUBSTITUTE-STRING.8 SUBSTITUTE-STRING.9

 SUBSTITUTE-STRING.10 SUBSTITUTE-STRING.11 SUBSTITUTE-STRING.12

 SUBSTITUTE-STRING.13 SUBSTITUTE-STRING.14 SUBSTITUTE-STRING.15

 SUBSTITUTE-STRING.16 SUBSTITUTE-STRING.17 SUBSTITUTE-STRING.18

 SUBSTITUTE-STRING.19 SUBSTITUTE-STRING.20 SUBSTITUTE-STRING.21

 SUBSTITUTE-STRING.22 SUBSTITUTE-STRING.23 SUBSTITUTE-STRING.24

 SUBSTITUTE-STRING.25 SUBSTITUTE-STRING.26 SUBSTITUTE-STRING.27

 SUBSTITUTE-STRING.28 SUBSTITUTE-STRING.29 SUBSTITUTE-STRING.30

 SUBSTITUTE-STRING.31 SUBSTITUTE-STRING.32 SUBSTITUTE-BIT-VECTOR.1

 SUBSTITUTE-BIT-VECTOR.2 SUBSTITUTE-BIT-VECTOR.3 SUBSTITUTE-BIT-VECTOR.4

 SUBSTITUTE-BIT-VECTOR.5 SUBSTITUTE-BIT-VECTOR.6 SUBSTITUTE-BIT-VECTOR.7

 SUBSTITUTE-BIT-VECTOR.8 SUBSTITUTE-BIT-VECTOR.9

 SUBSTITUTE-BIT-VECTOR.10 SUBSTITUTE-BIT-VECTOR.11

 SUBSTITUTE-BIT-VECTOR.12 SUBSTITUTE-BIT-VECTOR.13

 SUBSTITUTE-BIT-VECTOR.14 SUBSTITUTE-BIT-VECTOR.15

 SUBSTITUTE-BIT-VECTOR.16 SUBSTITUTE-BIT-VECTOR.17

 SUBSTITUTE-BIT-VECTOR.18 SUBSTITUTE-BIT-VECTOR.19

 SUBSTITUTE-BIT-VECTOR.20 SUBSTITUTE-BIT-VECTOR.21

 SUBSTITUTE-BIT-VECTOR.22 SUBSTITUTE-BIT-VECTOR.23

 SUBSTITUTE-BIT-VECTOR.24 SUBSTITUTE-BIT-VECTOR.25

 SUBSTITUTE-BIT-VECTOR.26 SUBSTITUTE-BIT-VECTOR.27

 SUBSTITUTE-BIT-VECTOR.28 SUBSTITUTE-BIT-VECTOR.29

 SUBSTITUTE-BIT-VECTOR.30 SUBSTITUTE-BIT-VECTOR.31

 SUBSTITUTE-BIT-VECTOR.32 SUBSTITUTE-BIT-VECTOR.33

 SUBSTITUTE.TEST-AND-TEST-NOT.1 SUBSTITUTE.TEST-AND-TEST-NOT.2

 SUBSTITUTE.TEST-AND-TEST-NOT.3 SUBSTITUTE.TEST-AND-TEST-NOT.4

 SUBSTITUTE.TEST-AND-TEST-NOT.5 SUBSTITUTE.TEST-AND-TEST-NOT.6

 SUBSTITUTE.TEST-AND-TEST-NOT.7 SUBSTITUTE.TEST-AND-TEST-NOT.8

 SUBSTITUTE.ORDER.1 SUBSTITUTE.ORDER.2 SUBSTITUTE.ALLOW-OTHER-KEYS.1

 SUBSTITUTE.ALLOW-OTHER-KEYS.2 SUBSTITUTE.ALLOW-OTHER-KEYS.3

 SUBSTITUTE.ALLOW-OTHER-KEYS.4 SUBSTITUTE.ALLOW-OTHER-KEYS.5

 SUBSTITUTE.KEYWORDS.6 SUBSTITUTE.ALLOW-OTHER-KEYS.7

 SUBSTITUTE.ALLOW-OTHER-KEYS.8 SUBSTITUTE.FOLD.1 SUBSTITUTE.FOLD.2

 SUBSTITUTE.FOLD.3 SUBSTITUTE.FOLD.4 SUBSTITUTE.ERROR.1

 SUBSTITUTE.ERROR.2 SUBSTITUTE.ERROR.3 SUBSTITUTE.ERROR.4

 SUBSTITUTE.ERROR.5 SUBSTITUTE.ERROR.6 SUBSTITUTE.ERROR.7

 SUBSTITUTE.ERROR.8 SUBSTITUTE.ERROR.9 SUBSTITUTE.ERROR.10

 SUBSTITUTE.ERROR.11 SUBSTITUTE.ERROR.12 SUBSTITUTE-IF-LIST.1

 SUBSTITUTE-IF-LIST.2 SUBSTITUTE-IF-LIST.3 SUBSTITUTE-IF-LIST.4

 SUBSTITUTE-IF-LIST.5 SUBSTITUTE-IF-LIST.6 SUBSTITUTE-IF-LIST.7

 SUBSTITUTE-IF-LIST.8 SUBSTITUTE-IF-LIST.9 SUBSTITUTE-IF-LIST.10

 SUBSTITUTE-IF-LIST.11 SUBSTITUTE-IF-LIST.12 SUBSTITUTE-IF-LIST.13

 SUBSTITUTE-IF-LIST.14 SUBSTITUTE-IF-LIST.15 SUBSTITUTE-IF-LIST.16

 SUBSTITUTE-IF-LIST.17 SUBSTITUTE-IF-LIST.18 SUBSTITUTE-IF-VECTOR.1

 SUBSTITUTE-IF-VECTOR.2 SUBSTITUTE-IF-VECTOR.3 SUBSTITUTE-IF-VECTOR.4

 SUBSTITUTE-IF-VECTOR.5 SUBSTITUTE-IF-VECTOR.6 SUBSTITUTE-IF-VECTOR.7

 SUBSTITUTE-IF-VECTOR.8 SUBSTITUTE-IF-VECTOR.9 SUBSTITUTE-IF-VECTOR.10

 SUBSTITUTE-IF-VECTOR.11 SUBSTITUTE-IF-VECTOR.12 SUBSTITUTE-IF-VECTOR.13

 SUBSTITUTE-IF-VECTOR.14 SUBSTITUTE-IF-VECTOR.15 SUBSTITUTE-IF-VECTOR.16

 SUBSTITUTE-IF-VECTOR.17 SUBSTITUTE-IF-VECTOR.18 SUBSTITUTE-IF-VECTOR.28

 SUBSTITUTE-IF-VECTOR.29 SUBSTITUTE-IF-VECTOR.30 SUBSTITUTE-IF-VECTOR.31

 SUBSTITUTE-IF-VECTOR.32 SUBSTITUTE-IF-VECTOR.33 SUBSTITUTE-IF-STRING.1

 SUBSTITUTE-IF-STRING.2 SUBSTITUTE-IF-STRING.3 SUBSTITUTE-IF-STRING.4

 SUBSTITUTE-IF-STRING.5 SUBSTITUTE-IF-STRING.6 SUBSTITUTE-IF-STRING.7

 SUBSTITUTE-IF-STRING.8 SUBSTITUTE-IF-STRING.9 SUBSTITUTE-IF-STRING.10

 SUBSTITUTE-IF-STRING.11 SUBSTITUTE-IF-STRING.12 SUBSTITUTE-IF-STRING.13

 SUBSTITUTE-IF-STRING.14 SUBSTITUTE-IF-STRING.15 SUBSTITUTE-IF-STRING.16

 SUBSTITUTE-IF-STRING.17 SUBSTITUTE-IF-STRING.18 SUBSTITUTE-IF-STRING.28

 SUBSTITUTE-IF-STRING.29 SUBSTITUTE-IF-STRING.30 SUBSTITUTE-IF-STRING.31

 SUBSTITUTE-IF-BIT-VECTOR.1 SUBSTITUTE-IF-BIT-VECTOR.2

 SUBSTITUTE-IF-BIT-VECTOR.3 SUBSTITUTE-IF-BIT-VECTOR.4

 SUBSTITUTE-IF-BIT-VECTOR.5 SUBSTITUTE-IF-BIT-VECTOR.6

 SUBSTITUTE-IF-BIT-VECTOR.7 SUBSTITUTE-IF-BIT-VECTOR.8

 SUBSTITUTE-IF-BIT-VECTOR.9 SUBSTITUTE-IF-BIT-VECTOR.10

 SUBSTITUTE-IF-BIT-VECTOR.11 SUBSTITUTE-IF-BIT-VECTOR.12

 SUBSTITUTE-IF-BIT-VECTOR.13 SUBSTITUTE-IF-BIT-VECTOR.14

 SUBSTITUTE-IF-BIT-VECTOR.15 SUBSTITUTE-IF-BIT-VECTOR.16

 SUBSTITUTE-IF-BIT-VECTOR.17 SUBSTITUTE-IF-BIT-VECTOR.18

 SUBSTITUTE-IF-BIT-VECTOR.19 SUBSTITUTE-IF-BIT-VECTOR.20

 SUBSTITUTE-IF-BIT-VECTOR.21 SUBSTITUTE-IF-LIST.24 SUBSTITUTE-IF-LIST.25

 SUBSTITUTE-IF-VECTOR.24 SUBSTITUTE-IF-VECTOR.25 SUBSTITUTE-IF-STRING.24

 SUBSTITUTE-IF-STRING.25 SUBSTITUTE-IF-STRING.26

 SUBSTITUTE-IF-BIT-VECTOR.22 SUBSTITUTE-IF-BIT-VECTOR.23

 SUBSTITUTE-IF-BIT-VECTOR.24 SUBSTITUTE-IF-BIT-VECTOR.25

 SUBSTITUTE-IF-BIT-VECTOR.26 SUBSTITUTE-IF-BIT-VECTOR.27

 SUBSTITUTE-IF.ORDER.1 SUBSTITUTE-IF.ORDER.2

 SUBSTITUTE-IF.ALLOW-OTHER-KEYS.1 SUBSTITUTE-IF.ALLOW-OTHER-KEYS.2

 SUBSTITUTE-IF.ALLOW-OTHER-KEYS.3 SUBSTITUTE-IF.ALLOW-OTHER-KEYS.4

 SUBSTITUTE-IF.ALLOW-OTHER-KEYS.5 SUBSTITUTE-IF.KEYWORDS.6

 SUBSTITUTE-IF.ALLOW-OTHER-KEYS.7 SUBSTITUTE-IF.ALLOW-OTHER-KEYS.8

 SUBSTITUTE-IF.FOLD.1 SUBSTITUTE-IF.FOLD.2 SUBSTITUTE-IF.FOLD.3

 SUBSTITUTE-IF.FOLD.4 SUBSTITUTE-IF.ERROR.1 SUBSTITUTE-IF.ERROR.2

 SUBSTITUTE-IF.ERROR.3 SUBSTITUTE-IF.ERROR.4 SUBSTITUTE-IF.ERROR.5

 SUBSTITUTE-IF.ERROR.6 SUBSTITUTE-IF.ERROR.7 SUBSTITUTE-IF.ERROR.8

 SUBSTITUTE-IF.ERROR.9 SUBSTITUTE-IF.ERROR.10 SUBSTITUTE-IF.ERROR.11

 SUBSTITUTE-IF.ERROR.12 SUBSTITUTE-IF-NOT-LIST.1

 SUBSTITUTE-IF-NOT-LIST.2 SUBSTITUTE-IF-NOT-LIST.3

 SUBSTITUTE-IF-NOT-LIST.4 SUBSTITUTE-IF-NOT-LIST.5

 SUBSTITUTE-IF-NOT-LIST.6 SUBSTITUTE-IF-NOT-LIST.7

 SUBSTITUTE-IF-NOT-LIST.8 SUBSTITUTE-IF-NOT-LIST.9

 SUBSTITUTE-IF-NOT-LIST.10 SUBSTITUTE-IF-NOT-LIST.11

 SUBSTITUTE-IF-NOT-LIST.12 SUBSTITUTE-IF-NOT-LIST.13

 SUBSTITUTE-IF-NOT-LIST.14 SUBSTITUTE-IF-NOT-LIST.15

 SUBSTITUTE-IF-NOT-LIST.16 SUBSTITUTE-IF-NOT-LIST.17

 SUBSTITUTE-IF-NOT-LIST.18 SUBSTITUTE-IF-NOT-VECTOR.1

 SUBSTITUTE-IF-NOT-VECTOR.2 SUBSTITUTE-IF-NOT-VECTOR.3

 SUBSTITUTE-IF-NOT-VECTOR.4 SUBSTITUTE-IF-NOT-VECTOR.5

 SUBSTITUTE-IF-NOT-VECTOR.6 SUBSTITUTE-IF-NOT-VECTOR.7

 SUBSTITUTE-IF-NOT-VECTOR.8 SUBSTITUTE-IF-NOT-VECTOR.9

 SUBSTITUTE-IF-NOT-VECTOR.10 SUBSTITUTE-IF-NOT-VECTOR.11

 SUBSTITUTE-IF-NOT-VECTOR.12 SUBSTITUTE-IF-NOT-VECTOR.13

 SUBSTITUTE-IF-NOT-VECTOR.14 SUBSTITUTE-IF-NOT-VECTOR.15

 SUBSTITUTE-IF-NOT-VECTOR.16 SUBSTITUTE-IF-NOT-VECTOR.17

 SUBSTITUTE-IF-NOT-VECTOR.18 SUBSTITUTE-IF-NOT-VECTOR.28

 SUBSTITUTE-IF-NOT-VECTOR.29 SUBSTITUTE-IF-NOT-VECTOR.30

 SUBSTITUTE-IF-NOT-VECTOR.31 SUBSTITUTE-IF-NOT-VECTOR.32

 SUBSTITUTE-IF-NOT-VECTOR.33 SUBSTITUTE-IF-NOT-STRING.1

 SUBSTITUTE-IF-NOT-STRING.2 SUBSTITUTE-IF-NOT-STRING.3

 SUBSTITUTE-IF-NOT-STRING.4 SUBSTITUTE-IF-NOT-STRING.5

 SUBSTITUTE-IF-NOT-STRING.6 SUBSTITUTE-IF-NOT-STRING.7

 SUBSTITUTE-IF-NOT-STRING.8 SUBSTITUTE-IF-NOT-STRING.9

 SUBSTITUTE-IF-NOT-STRING.10 SUBSTITUTE-IF-NOT-STRING.11

 SUBSTITUTE-IF-NOT-STRING.12 SUBSTITUTE-IF-NOT-STRING.13

 SUBSTITUTE-IF-NOT-STRING.14 SUBSTITUTE-IF-NOT-STRING.15

 SUBSTITUTE-IF-NOT-STRING.16 SUBSTITUTE-IF-NOT-STRING.17

 SUBSTITUTE-IF-NOT-STRING.18 SUBSTITUTE-IF-NOT-STRING.28

 SUBSTITUTE-IF-NOT-STRING.29 SUBSTITUTE-IF-NOT-STRING.30

 SUBSTITUTE-IF-NOT-STRING.31 SUBSTITUTE-IF-NOT-BITSTRING.1

 SUBSTITUTE-IF-NOT-BITSTRING.2 SUBSTITUTE-IF-NOT-BITSTRING.3

 SUBSTITUTE-IF-NOT-BITSTRING.4 SUBSTITUTE-IF-NOT-BITSTRING.5

 SUBSTITUTE-IF-NOT-BITSTRING.6 SUBSTITUTE-IF-NOT-BITSTRING.7

 SUBSTITUTE-IF-NOT-BITSTRING.8 SUBSTITUTE-IF-NOT-BITSTRING.9

 SUBSTITUTE-IF-NOT-BITSTRING.10 SUBSTITUTE-IF-NOT-BITSTRING.11

 SUBSTITUTE-IF-NOT-BITSTRING.12 SUBSTITUTE-IF-NOT-BITSTRING.13

 SUBSTITUTE-IF-NOT-BITSTRING.14 SUBSTITUTE-IF-NOT-BITSTRING.15

 SUBSTITUTE-IF-NOT-BITSTRING.16 SUBSTITUTE-IF-NOT-BITSTRING.17

 SUBSTITUTE-IF-NOT-BITSTRING.18 SUBSTITUTE-IF-NOT-BITSTRING.19

 SUBSTITUTE-IF-NOT-BITSTRING.20 SUBSTITUTE-IF-NOT-BITSTRING.21

 SUBSTITUTE-IF-NOT-LIST.24 SUBSTITUTE-IF-NOT-LIST.25

 SUBSTITUTE-IF-NOT-VECTOR.24 SUBSTITUTE-IF-NOT-VECTOR.25

 SUBSTITUTE-IF-NOT-STRING.24 SUBSTITUTE-IF-NOT-STRING.25

 SUBSTITUTE-IF-NOT-STRING.26 SUBSTITUTE-IF-NOT-BITSTRING.26

 SUBSTITUTE-IF-NOT-BITSTRING.27 SUBSTITUTE-IF-NOT-BIT-VECTOR.30

 SUBSTITUTE-IF-NOT-BIT-VECTOR.31 SUBSTITUTE-IF-NOT-BIT-VECTOR.32

 SUBSTITUTE-IF-NOT-BIT-VECTOR.33 SUBSTITUTE-IF-NOT.ORDER.1

 SUBSTITUTE-IF-NOT.ORDER.2 SUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.1

 SUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.2

 SUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.3

 SUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.4

 SUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.5 SUBSTITUTE-IF-NOT.KEYWORDS.6

 SUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.7

 SUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.8 SUBSTITUTE-IF-NOT.FOLD.1

 SUBSTITUTE-IF-NOT.FOLD.2 SUBSTITUTE-IF-NOT.FOLD.3

 SUBSTITUTE-IF-NOT.FOLD.4 SUBSTITUTE-IF-NOT.ERROR.1

 SUBSTITUTE-IF-NOT.ERROR.2 SUBSTITUTE-IF-NOT.ERROR.3

 SUBSTITUTE-IF-NOT.ERROR.4 SUBSTITUTE-IF-NOT.ERROR.5

 SUBSTITUTE-IF-NOT.ERROR.6 SUBSTITUTE-IF-NOT.ERROR.7

 SUBSTITUTE-IF-NOT.ERROR.8 SUBSTITUTE-IF-NOT.ERROR.9

 SUBSTITUTE-IF-NOT.ERROR.10 SUBSTITUTE-IF-NOT.ERROR.11

 SUBSTITUTE-IF-NOT.ERROR.12 NSUBSTITUTE-LIST.1 NSUBSTITUTE-LIST.2

 NSUBSTITUTE-LIST.3 NSUBSTITUTE-LIST.4 NSUBSTITUTE-LIST.5

 NSUBSTITUTE-LIST.6 NSUBSTITUTE-LIST.7 NSUBSTITUTE-LIST.8

 NSUBSTITUTE-LIST.9 NSUBSTITUTE-LIST.10 NSUBSTITUTE-LIST.11

 NSUBSTITUTE-LIST.12 NSUBSTITUTE-LIST.13 NSUBSTITUTE-LIST.14

 NSUBSTITUTE-LIST.15 NSUBSTITUTE-LIST.16 NSUBSTITUTE-LIST.17

 NSUBSTITUTE-LIST.18 NSUBSTITUTE-LIST.19 NSUBSTITUTE-LIST.20

 NSUBSTITUTE-LIST.21 NSUBSTITUTE-LIST.22 NSUBSTITUTE-LIST.23

 NSUBSTITUTE-VECTOR.1 NSUBSTITUTE-VECTOR.2 NSUBSTITUTE-VECTOR.3

 NSUBSTITUTE-VECTOR.4 NSUBSTITUTE-VECTOR.5 NSUBSTITUTE-VECTOR.6

 NSUBSTITUTE-VECTOR.7 NSUBSTITUTE-VECTOR.8 NSUBSTITUTE-VECTOR.9

 NSUBSTITUTE-VECTOR.10 NSUBSTITUTE-VECTOR.11 NSUBSTITUTE-VECTOR.12

 NSUBSTITUTE-VECTOR.13 NSUBSTITUTE-VECTOR.14 NSUBSTITUTE-VECTOR.15

 NSUBSTITUTE-VECTOR.16 NSUBSTITUTE-VECTOR.17 NSUBSTITUTE-VECTOR.18

 NSUBSTITUTE-VECTOR.19 NSUBSTITUTE-VECTOR.20 NSUBSTITUTE-VECTOR.21

 NSUBSTITUTE-VECTOR.22 NSUBSTITUTE-VECTOR.23 NSUBSTITUTE-VECTOR.28

 NSUBSTITUTE-VECTOR.29 NSUBSTITUTE-VECTOR.30 NSUBSTITUTE-VECTOR.31

 NSUBSTITUTE-STRING.1 NSUBSTITUTE-STRING.2 NSUBSTITUTE-STRING.3

 NSUBSTITUTE-STRING.4 NSUBSTITUTE-STRING.5 NSUBSTITUTE-STRING.6

 NSUBSTITUTE-STRING.7 NSUBSTITUTE-STRING.8 NSUBSTITUTE-STRING.9

 NSUBSTITUTE-STRING.10 NSUBSTITUTE-STRING.11 NSUBSTITUTE-STRING.12

 NSUBSTITUTE-STRING.13 NSUBSTITUTE-STRING.14 NSUBSTITUTE-STRING.15

 NSUBSTITUTE-STRING.16 NSUBSTITUTE-STRING.17 NSUBSTITUTE-STRING.18

 NSUBSTITUTE-STRING.19 NSUBSTITUTE-STRING.20 NSUBSTITUTE-STRING.21

 NSUBSTITUTE-STRING.22 NSUBSTITUTE-STRING.23 NSUBSTITUTE-STRING.28

 NSUBSTITUTE-STRING.29 NSUBSTITUTE-STRING.30 NSUBSTITUTE-STRING.31

 NSUBSTITUTE-BIT-VECTOR.1 NSUBSTITUTE-BIT-VECTOR.2

 NSUBSTITUTE-BIT-VECTOR.3 NSUBSTITUTE-BIT-VECTOR.4

 NSUBSTITUTE-BIT-VECTOR.5 NSUBSTITUTE-BIT-VECTOR.6

 NSUBSTITUTE-BIT-VECTOR.7 NSUBSTITUTE-BIT-VECTOR.8

 NSUBSTITUTE-BIT-VECTOR.9 NSUBSTITUTE-BIT-VECTOR.10

 NSUBSTITUTE-BIT-VECTOR.11 NSUBSTITUTE-BIT-VECTOR.12

 NSUBSTITUTE-BIT-VECTOR.13 NSUBSTITUTE-BIT-VECTOR.14

 NSUBSTITUTE-BIT-VECTOR.15 NSUBSTITUTE-BIT-VECTOR.16

 NSUBSTITUTE-BIT-VECTOR.17 NSUBSTITUTE-BIT-VECTOR.18

 NSUBSTITUTE-BIT-VECTOR.19 NSUBSTITUTE-BIT-VECTOR.20

 NSUBSTITUTE-BIT-VECTOR.21 NSUBSTITUTE-BIT-VECTOR.22

 NSUBSTITUTE-BIT-VECTOR.23 NSUBSTITUTE-BIT-VECTOR.24

 NSUBSTITUTE-BIT-VECTOR.25 NSUBSTITUTE.TEST-AND-TEST-NOT.1

 NSUBSTITUTE.TEST-AND-TEST-NOT.2 NSUBSTITUTE.TEST-AND-TEST-NOT.3

 NSUBSTITUTE.TEST-AND-TEST-NOT.4 NSUBSTITUTE.TEST-AND-TEST-NOT.5

 NSUBSTITUTE.TEST-AND-TEST-NOT.6 NSUBSTITUTE.TEST-AND-TEST-NOT.7

 NSUBSTITUTE.TEST-AND-TEST-NOT.8 NSUBSTITUTE-LIST.24 NSUBSTITUTE-LIST.25

 NSUBSTITUTE-LIST.26 NSUBSTITUTE-LIST.27 NSUBSTITUTE-VECTOR.24

 NSUBSTITUTE-VECTOR.25 NSUBSTITUTE-VECTOR.26 NSUBSTITUTE-VECTOR.27

 NSUBSTITUTE-VECTOR.32 NSUBSTITUTE-VECTOR.33 NSUBSTITUTE-STRING.24

 NSUBSTITUTE-STRING.25 NSUBSTITUTE-STRING.26 NSUBSTITUTE-STRING.27

 NSUBSTITUTE-STRING.32 NSUBSTITUTE-STRING.33 NSUBSTITUTE-STRING.34

 NSUBSTITUTE-BIT-VECTOR.30 NSUBSTITUTE-BIT-VECTOR.31

 NSUBSTITUTE-BIT-VECTOR.32 NSUBSTITUTE-BIT-VECTOR.33 NSUBSTITUTE.ORDER.1

 NSUBSTITUTE.ORDER.2 NSUBSTITUTE.ALLOW-OTHER-KEYS.1

 NSUBSTITUTE.ALLOW-OTHER-KEYS.2 NSUBSTITUTE.ALLOW-OTHER-KEYS.3

 NSUBSTITUTE.ALLOW-OTHER-KEYS.4 NSUBSTITUTE.ALLOW-OTHER-KEYS.5

 NSUBSTITUTE.KEYWORDS.6 NSUBSTITUTE.ALLOW-OTHER-KEYS.7

 NSUBSTITUTE.ALLOW-OTHER-KEYS.8 NSUBSTITUTE.ERROR.1 NSUBSTITUTE.ERROR.2

 NSUBSTITUTE.ERROR.3 NSUBSTITUTE.ERROR.4 NSUBSTITUTE.ERROR.5

 NSUBSTITUTE.ERROR.6 NSUBSTITUTE.ERROR.7 NSUBSTITUTE.ERROR.8

 NSUBSTITUTE.ERROR.9 NSUBSTITUTE.ERROR.10 NSUBSTITUTE.ERROR.11

 NSUBSTITUTE.ERROR.12 NSUBSTITUTE-IF-LIST.1 NSUBSTITUTE-IF-LIST.2

 NSUBSTITUTE-IF-LIST.3 NSUBSTITUTE-IF-LIST.4 NSUBSTITUTE-IF-LIST.5

 NSUBSTITUTE-IF-LIST.6 NSUBSTITUTE-IF-LIST.7 NSUBSTITUTE-IF-LIST.8

 NSUBSTITUTE-IF-LIST.9 NSUBSTITUTE-IF-LIST.10 NSUBSTITUTE-IF-LIST.11

 NSUBSTITUTE-IF-LIST.12 NSUBSTITUTE-IF-LIST.13 NSUBSTITUTE-IF-LIST.14

 NSUBSTITUTE-IF-LIST.15 NSUBSTITUTE-IF-LIST.16 NSUBSTITUTE-IF-LIST.17

 NSUBSTITUTE-IF-LIST.18 NSUBSTITUTE-IF-VECTOR.1 NSUBSTITUTE-IF-VECTOR.2

 NSUBSTITUTE-IF-VECTOR.3 NSUBSTITUTE-IF-VECTOR.4 NSUBSTITUTE-IF-VECTOR.5

 NSUBSTITUTE-IF-VECTOR.6 NSUBSTITUTE-IF-VECTOR.7 NSUBSTITUTE-IF-VECTOR.8

 NSUBSTITUTE-IF-VECTOR.9 NSUBSTITUTE-IF-VECTOR.10

 NSUBSTITUTE-IF-VECTOR.11 NSUBSTITUTE-IF-VECTOR.12

 NSUBSTITUTE-IF-VECTOR.13 NSUBSTITUTE-IF-VECTOR.14

 NSUBSTITUTE-IF-VECTOR.15 NSUBSTITUTE-IF-VECTOR.16

 NSUBSTITUTE-IF-VECTOR.17 NSUBSTITUTE-IF-VECTOR.18

 NSUBSTITUTE-IF-VECTOR.28 NSUBSTITUTE-IF-VECTOR.29

 NSUBSTITUTE-IF-VECTOR.30 NSUBSTITUTE-IF-VECTOR.31

 NSUBSTITUTE-IF-VECTOR.32 NSUBSTITUTE-IF-VECTOR.33

 NSUBSTITUTE-IF-STRING.1 NSUBSTITUTE-IF-STRING.2 NSUBSTITUTE-IF-STRING.3

 NSUBSTITUTE-IF-STRING.4 NSUBSTITUTE-IF-STRING.5 NSUBSTITUTE-IF-STRING.6

 NSUBSTITUTE-IF-STRING.7 NSUBSTITUTE-IF-STRING.8 NSUBSTITUTE-IF-STRING.9

 NSUBSTITUTE-IF-STRING.10 NSUBSTITUTE-IF-STRING.11

 NSUBSTITUTE-IF-STRING.12 NSUBSTITUTE-IF-STRING.13

 NSUBSTITUTE-IF-STRING.14 NSUBSTITUTE-IF-STRING.15

 NSUBSTITUTE-IF-STRING.16 NSUBSTITUTE-IF-STRING.17

 NSUBSTITUTE-IF-STRING.18 NSUBSTITUTE-IF-STRING.28

 NSUBSTITUTE-IF-STRING.29 NSUBSTITUTE-IF-STRING.30

 NSUBSTITUTE-IF-STRING.31 NSUBSTITUTE-IF-STRING.32

 NSUBSTITUTE-IF-STRING.33 NSUBSTITUTE-IF-STRING.34

 NSUBSTITUTE-IF-BIT-VECTOR.1 NSUBSTITUTE-IF-BIT-VECTOR.2

 NSUBSTITUTE-IF-BIT-VECTOR.3 NSUBSTITUTE-IF-BIT-VECTOR.4

 NSUBSTITUTE-IF-BIT-VECTOR.5 NSUBSTITUTE-IF-BIT-VECTOR.6

 NSUBSTITUTE-IF-BIT-VECTOR.7 NSUBSTITUTE-IF-BIT-VECTOR.8

 NSUBSTITUTE-IF-BIT-VECTOR.9 NSUBSTITUTE-IF-BIT-VECTOR.10

 NSUBSTITUTE-IF-BIT-VECTOR.11 NSUBSTITUTE-IF-BIT-VECTOR.12

 NSUBSTITUTE-IF-BIT-VECTOR.13 NSUBSTITUTE-IF-BIT-VECTOR.14

 NSUBSTITUTE-IF-BIT-VECTOR.15 NSUBSTITUTE-IF-BIT-VECTOR.16

 NSUBSTITUTE-IF-BIT-VECTOR.17 NSUBSTITUTE-IF-BIT-VECTOR.18

 NSUBSTITUTE-IF-BIT-VECTOR.19 NSUBSTITUTE-IF-BIT-VECTOR.20

 NSUBSTITUTE-IF-BIT-VECTOR.21 NSUBSTITUTE-IF-LIST.24

 NSUBSTITUTE-IF-LIST.25 NSUBSTITUTE-IF-VECTOR.24

 NSUBSTITUTE-IF-VECTOR.25 NSUBSTITUTE-IF-STRING.24

 NSUBSTITUTE-IF-STRING.25 NSUBSTITUTE-IF-BIT-VECTOR.26

 NSUBSTITUTE-IF-BIT-VECTOR.27 NSUBSTITUTE-IF-BIT-VECTOR.30

 NSUBSTITUTE-IF-BIT-VECTOR.31 NSUBSTITUTE-IF-BIT-VECTOR.32

 NSUBSTITUTE-IF-BIT-VECTOR.33 NSUBSTITUTE-IF.ORDER.1

 NSUBSTITUTE-IF.ORDER.2 NSUBSTITUTE-IF.ALLOW-OTHER-KEYS.1

 NSUBSTITUTE-IF.ALLOW-OTHER-KEYS.2 NSUBSTITUTE-IF.ALLOW-OTHER-KEYS.3

 NSUBSTITUTE-IF.ALLOW-OTHER-KEYS.4 NSUBSTITUTE-IF.ALLOW-OTHER-KEYS.5

 NSUBSTITUTE-IF.KEYWORDS.6 NSUBSTITUTE-IF.ALLOW-OTHER-KEYS.7

 NSUBSTITUTE-IF.ALLOW-OTHER-KEYS.8 NSUBSTITUTE-IF.ERROR.1

 NSUBSTITUTE-IF.ERROR.2 NSUBSTITUTE-IF.ERROR.3 NSUBSTITUTE-IF.ERROR.4

 NSUBSTITUTE-IF.ERROR.5 NSUBSTITUTE-IF.ERROR.6 NSUBSTITUTE-IF.ERROR.7

 NSUBSTITUTE-IF.ERROR.8 NSUBSTITUTE-IF.ERROR.9 NSUBSTITUTE-IF.ERROR.10

 NSUBSTITUTE-IF.ERROR.11 NSUBSTITUTE-IF.ERROR.12

 NSUBSTITUTE-IF-NOT-LIST.1 NSUBSTITUTE-IF-NOT-LIST.2

 NSUBSTITUTE-IF-NOT-LIST.3 NSUBSTITUTE-IF-NOT-LIST.4

 NSUBSTITUTE-IF-NOT-LIST.5 NSUBSTITUTE-IF-NOT-LIST.6

 NSUBSTITUTE-IF-NOT-LIST.7 NSUBSTITUTE-IF-NOT-LIST.8

 NSUBSTITUTE-IF-NOT-LIST.9 NSUBSTITUTE-IF-NOT-LIST.10

 NSUBSTITUTE-IF-NOT-LIST.11 NSUBSTITUTE-IF-NOT-LIST.12

 NSUBSTITUTE-IF-NOT-LIST.13 NSUBSTITUTE-IF-NOT-LIST.14

 NSUBSTITUTE-IF-NOT-LIST.15 NSUBSTITUTE-IF-NOT-LIST.16

 NSUBSTITUTE-IF-NOT-LIST.17 NSUBSTITUTE-IF-NOT-LIST.18

 NSUBSTITUTE-IF-NOT-VECTOR.1 NSUBSTITUTE-IF-NOT-VECTOR.2

 NSUBSTITUTE-IF-NOT-VECTOR.3 NSUBSTITUTE-IF-NOT-VECTOR.4

 NSUBSTITUTE-IF-NOT-VECTOR.5 NSUBSTITUTE-IF-NOT-VECTOR.6

 NSUBSTITUTE-IF-NOT-VECTOR.7 NSUBSTITUTE-IF-NOT-VECTOR.8

 NSUBSTITUTE-IF-NOT-VECTOR.9 NSUBSTITUTE-IF-NOT-VECTOR.10

 NSUBSTITUTE-IF-NOT-VECTOR.11 NSUBSTITUTE-IF-NOT-VECTOR.12

 NSUBSTITUTE-IF-NOT-VECTOR.13 NSUBSTITUTE-IF-NOT-VECTOR.14

 NSUBSTITUTE-IF-NOT-VECTOR.15 NSUBSTITUTE-IF-NOT-VECTOR.16

 NSUBSTITUTE-IF-NOT-VECTOR.17 NSUBSTITUTE-IF-NOT-VECTOR.18

 NSUBSTITUTE-IF-NOT-VECTOR.28 NSUBSTITUTE-IF-NOT-VECTOR.29

 NSUBSTITUTE-IF-NOT-VECTOR.30 NSUBSTITUTE-IF-NOT-VECTOR.31

 NSUBSTITUTE-IF-NOT-VECTOR.32 NSUBSTITUTE-IF-NOT-VECTOR.33

 NSUBSTITUTE-IF-NOT-STRING.1 NSUBSTITUTE-IF-NOT-STRING.2

 NSUBSTITUTE-IF-NOT-STRING.3 NSUBSTITUTE-IF-NOT-STRING.4

 NSUBSTITUTE-IF-NOT-STRING.5 NSUBSTITUTE-IF-NOT-STRING.6

 NSUBSTITUTE-IF-NOT-STRING.7 NSUBSTITUTE-IF-NOT-STRING.8

 NSUBSTITUTE-IF-NOT-STRING.9 NSUBSTITUTE-IF-NOT-STRING.10

 NSUBSTITUTE-IF-NOT-STRING.11 NSUBSTITUTE-IF-NOT-STRING.12

 NSUBSTITUTE-IF-NOT-STRING.13 NSUBSTITUTE-IF-NOT-STRING.14

 NSUBSTITUTE-IF-NOT-STRING.15 NSUBSTITUTE-IF-NOT-STRING.16

 NSUBSTITUTE-IF-NOT-STRING.17 NSUBSTITUTE-IF-NOT-STRING.18

 NSUBSTITUTE-IF-NOT-STRING.28 NSUBSTITUTE-IF-NOT-STRING.29

 NSUBSTITUTE-IF-NOT-STRING.30 NSUBSTITUTE-IF-NOT-STRING.31

 NSUBSTITUTE-IF-NOT-STRING.32 NSUBSTITUTE-IF-NOT-STRING.33

 NSUBSTITUTE-IF-NOT-STRING.34 NSUBSTITUTE-IF-NOT-BIT-VECTOR.1

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.2 NSUBSTITUTE-IF-NOT-BIT-VECTOR.3

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.4 NSUBSTITUTE-IF-NOT-BIT-VECTOR.5

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.6 NSUBSTITUTE-IF-NOT-BIT-VECTOR.7

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.8 NSUBSTITUTE-IF-NOT-BIT-VECTOR.9

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.10 NSUBSTITUTE-IF-NOT-BIT-VECTOR.11

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.12 NSUBSTITUTE-IF-NOT-BIT-VECTOR.13

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.14 NSUBSTITUTE-IF-NOT-BIT-VECTOR.15

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.16 NSUBSTITUTE-IF-NOT-BIT-VECTOR.17

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.18 NSUBSTITUTE-IF-NOT-BIT-VECTOR.19

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.20 NSUBSTITUTE-IF-NOT-BIT-VECTOR.21

 NSUBSTITUTE-IF-NOT-LIST.24 NSUBSTITUTE-IF-NOT-LIST.25

 NSUBSTITUTE-IF-NOT-VECTOR.24 NSUBSTITUTE-IF-NOT-VECTOR.25

 NSUBSTITUTE-IF-NOT-STRING.24 NSUBSTITUTE-IF-NOT-STRING.25

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.26 NSUBSTITUTE-IF-NOT-BIT-VECTOR.27

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.30 NSUBSTITUTE-IF-NOT-BIT-VECTOR.31

 NSUBSTITUTE-IF-NOT-BIT-VECTOR.32 NSUBSTITUTE-IF-NOT-BIT-VECTOR.33

 NSUBSTITUTE-IF-NOT.ORDER.1 NSUBSTITUTE-IF-NOT.ORDER.2

 NSUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.1

 NSUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.2

 NSUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.3

 NSUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.4

 NSUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.5 NSUBSTITUTE-IF-NOT.KEYWORDS.6

 NSUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.7

 NSUBSTITUTE-IF-NOT.ALLOW-OTHER-KEYS.8 NSUBSTITUTE-IF-NOT.ERROR.1

 NSUBSTITUTE-IF-NOT.ERROR.2 NSUBSTITUTE-IF-NOT.ERROR.3

 NSUBSTITUTE-IF-NOT.ERROR.4 NSUBSTITUTE-IF-NOT.ERROR.5

 NSUBSTITUTE-IF-NOT.ERROR.6 NSUBSTITUTE-IF-NOT.ERROR.7

 NSUBSTITUTE-IF-NOT.ERROR.8 NSUBSTITUTE-IF-NOT.ERROR.9

 NSUBSTITUTE-IF-NOT.ERROR.10 NSUBSTITUTE-IF-NOT.ERROR.11

 NSUBSTITUTE-IF-NOT.ERROR.12 CONCATENATE.1 CONCATENATE.2 CONCATENATE.3

 CONCATENATE.4 CONCATENATE.5 CONCATENATE.6 CONCATENATE.7 CONCATENATE.8

 CONCATENATE.9 CONCATENATE.10 CONCATENATE.11 CONCATENATE.12

 CONCATENATE.13 CONCATENATE.14 CONCATENATE.15 CONCATENATE.16

 CONCATENATE.17 CONCATENATE.18 CONCATENATE.18A CONCATENATE.18B

 CONCATENATE.18C CONCATENATE.18D CONCATENATE.19 CONCATENATE.20

 CONCATENATE.21 CONCATENATE.22 CONCATENATE.23 CONCATENATE.24

 CONCATENATE.25 CONCATENATE.26 CONCATENATE.27 CONCATENATE.28

 CONCATENATE.29 CONCATENATE.30 CONCATENATE.30A CONCATENATE.33

 CONCATENATE.34 CONCATENATE.35 CONCATENATE.36 CONCATENATE.37

 CONCATENATE.38 CONCATENATE.39 CONCATENATE.40 CONCATENATE.ORDER.1

 CONCATENATE.ORDER.2 CONCATENATE.FOLD.1 CONCATENATE.FOLD.2

 CONCATENATE.FOLD.3 CONCATENATE.FOLD.4 CONCATENATE.FOLD.5

 CONCATENATE.FOLD.6 CONCATENATE.FOLD.7 CONCATENATE.FOLD.8

 CONCATENATE.ERROR.1 CONCATENATE.ERROR.2 CONCATENATE.ERROR.3

 CONCATENATE.ERROR.4 CONCATENATE.ERROR.5 CONCATENATE.ERROR.6

 MERGE-LIST.1 MERGE-LIST.2 MERGE-LIST.3 MERGE-LIST.4 MERGE-LIST.5

 MERGE-LIST.6 MERGE-LIST.7 MERGE-LIST.8 MERGE-LIST.9 MERGE-LIST.10

 MERGE-LIST.11 MERGE-LIST.12 MERGE-LIST.13 MERGE-LIST.14 MERGE-LIST.15

 MERGE-VECTOR.1 MERGE-VECTOR.2 MERGE-VECTOR.3 MERGE-VECTOR.4

 MERGE-VECTOR.5 MERGE-VECTOR.6 MERGE-VECTOR.7 MERGE-VECTOR.8

 MERGE-VECTOR.9 MERGE-VECTOR.10 MERGE-VECTOR.11 MERGE-VECTOR.12

 MERGE-VECTOR.13 MERGE-VECTOR.14 MERGE-VECTOR.15 MERGE-VECTOR.16

 MERGE-VECTOR.16A MERGE-VECTOR.17 MERGE-VECTOR.18 MERGE-VECTOR.19

 MERGE-VECTOR.20 MERGE-VECTOR.21 MERGE-VECTOR.22 MERGE-VECTOR.23

 MERGE-VECTOR.24 MERGE-STRING.1 MERGE-STRING.1A MERGE-STRING.1B

 MERGE-STRING.1C MERGE-STRING.1D MERGE-STRING.2 MERGE-STRING.3

 MERGE-STRING.4 MERGE-STRING.8 MERGE-STRING.9 MERGE-STRING.10

 MERGE-STRING.11 MERGE-STRING.12 MERGE-STRING.13 MERGE-STRING.13A

 MERGE-STRING.14 MERGE-STRING.14A MERGE-STRING.15 MERGE-STRING.16

 MERGE-STRING.17 MERGE-STRING.18 MERGE-STRING.19 MERGE-STRING.20

 MERGE-STRING.21 MERGE-STRING.22 MERGE-STRING.23 MERGE-STRING.24

 MERGE-STRING.25 MERGE-STRING.26 MERGE-STRING.27 MERGE-STRING.28

 MERGE-STRING.29 MERGE-STRING.30 MERGE-STRING.31 MERGE-STRING.32

 MERGE-STRING.33 MERGE-STRING.34 MERGE-STRING.35 MERGE-BIT-VECTOR.1

 MERGE-BIT-VECTOR.2 MERGE-BIT-VECTOR.3 MERGE-BIT-VECTOR.4

 MERGE-BIT-VECTOR.5 MERGE-BIT-VECTOR.5A MERGE-BIT-VECTOR.5B

 MERGE-BIT-VECTOR.5C MERGE-BIT-VECTOR.5D MERGE-BIT-VECTOR.5E

 MERGE-BIT-VECTOR.6 MERGE-BIT-VECTOR.7 MERGE-BIT-VECTOR.8

 MERGE-BIT-VECTOR.9 MERGE-BIT-VECTOR.10 MERGE-BIT-VECTOR.11

 MERGE-BIT-VECTOR.12 MERGE-BIT-VECTOR.13 MERGE-BIT-VECTOR.14

 MERGE-BIT-VECTOR.15 MERGE-BIT-VECTOR.16 MERGE-BIT-VECTOR.17

 MERGE-BIT-VECTOR.18 MERGE-BIT-VECTOR.19 MERGE-CONS.1 MERGE-NULL.1

 MERGE-VECTOR-LENGTH.1 MERGE-BIT-VECTOR-LENGTH.1 MERGE.ORDER.1

 MERGE.ERROR.1 MERGE.ERROR.2 MERGE.ERROR.3 MERGE.ERROR.4 MERGE.ERROR.5

 MERGE.ERROR.6 MERGE.ERROR.7 MERGE.ERROR.8 MERGE.ERROR.9 MERGE.ERROR.10

 MERGE.ERROR.11 MERGE.ERROR.12 MERGE.ERROR.13 MERGE.ERROR.14

 MERGE.ERROR.15 MERGE.ERROR.16 MERGE.ERROR.17 REMOVE-LIST.1

 REMOVE-LIST.2 REMOVE-LIST.3 REMOVE-LIST.4 REMOVE-LIST.5 REMOVE-LIST.6

 REMOVE-LIST.7 REMOVE-LIST.8 REMOVE-LIST.9 REMOVE-LIST.10 REMOVE-LIST.11

 REMOVE-LIST.12 REMOVE-LIST.13 REMOVE-LIST.14 REMOVE-LIST.15

 REMOVE-LIST.16 REMOVE-LIST.17 REMOVE-LIST.19 REMOVE-LIST.20

 REMOVE-LIST.21 REMOVE-LIST.22 REMOVE-LIST.23 REMOVE-LIST.24

 REMOVE-LIST.25 REMOVE-LIST.26 REMOVE-LIST.27 REMOVE-LIST.28

 REMOVE-LIST.29 REMOVE-VECTOR.1 REMOVE-VECTOR.2 REMOVE-VECTOR.3

 REMOVE-STRING.1 REMOVE-STRING.2 REMOVE-STRING.3 REMOVE-STRING.4

 DELETE-VECTOR.1 DELETE-VECTOR.2 DELETE-VECTOR.3 DELETE-STRING.1

 DELETE-STRING.2 DELETE-STRING.3 DELETE-STRING.4 DELETE-STRING.5

 DELETE-STRING.6 REMOVE-BIT-VECTOR.1 REMOVE-BIT-VECTOR.2

 REMOVE-BIT-VECTOR.3 DELETE-BIT-VECTOR.1 DELETE-BIT-VECTOR.2

 DELETE-BIT-VECTOR.3 REMOVE-LIST.TEST-AND-TEST-NOT.1

 REMOVE-LIST.TEST-AND-TEST-NOT.2 REMOVE-VECTOR.TEST-AND-TEST-NOT.1

 REMOVE-VECTOR.TEST-AND-TEST-NOT.2 REMOVE-BIT-STRING.TEST-AND-TEST-NOT.1

 REMOVE-BIT-STRING.TEST-AND-TEST-NOT.2 REMOVE-STRING.TEST-AND-TEST-NOT.1

 REMOVE-STRING.TEST-AND-TEST-NOT.2 DELETE-LIST.TEST-AND-TEST-NOT.1

 DELETE-LIST.TEST-AND-TEST-NOT.2 DELETE-VECTOR.TEST-AND-TEST-NOT.1

 DELETE-VECTOR.TEST-AND-TEST-NOT.2 DELETE-BIT-STRING.TEST-AND-TEST-NOT.1

 DELETE-BIT-STRING.TEST-AND-TEST-NOT.2 DELETE-STRING.TEST-AND-TEST-NOT.1

 DELETE-STRING.TEST-AND-TEST-NOT.2 REMOVE.FOLD.1 REMOVE.FOLD.2

 REMOVE.FOLD.3 REMOVE.FOLD.4 REMOVE-IF.FOLD.1 REMOVE-IF.FOLD.2

 REMOVE-IF.FOLD.3 REMOVE-IF.FOLD.4 REMOVE-IF-NOT.FOLD.1

 REMOVE-IF-NOT.FOLD.2 REMOVE-IF-NOT.FOLD.3 REMOVE-IF-NOT.FOLD.4

 REMOVE.ORDER.1 REMOVE.ORDER.2 DELETE.ORDER.1 DELETE.ORDER.2

 REMOVE-IF.ORDER.1 REMOVE-IF.ORDER.2 DELETE-IF.ORDER.1 DELETE-IF.ORDER.2

 REMOVE-IF-NOT.ORDER.1 REMOVE-IF-NOT.ORDER.2 DELETE-IF-NOT.ORDER.1

 DELETE-IF-NOT.ORDER.2 REMOVE-RANDOM REMOVE-IF-RANDOM

 REMOVE-IF-NOT-RANDOM DELETE-RANDOM DELETE-IF-RANDOM

 DELETE-IF-NOT-RANDOM REMOVE-IF-LIST.1 REMOVE-IF-LIST.2

 REMOVE-IF-NOT-LIST.1 REMOVE-IF-NOT-LIST.2 DELETE-IF-LIST.1

 DELETE-IF-LIST.2 DELETE-IF-NOT-LIST.1 DELETE-IF-NOT-LIST.2

 DELETE-LIST.1 DELETE-LIST.2 REMOVE.ALLOW-OTHER-KEYS.1

 REMOVE.ALLOW-OTHER-KEYS.2 REMOVE.ALLOW-OTHER-KEYS.3

 REMOVE.ALLOW-OTHER-KEYS.4 REMOVE.ALLOW-OTHER-KEYS.5

 REMOVE.ALLOW-OTHER-KEYS.6 REMOVE.KEYWORDS.7 DELETE.ALLOW-OTHER-KEYS.1

 DELETE.ALLOW-OTHER-KEYS.2 DELETE.ALLOW-OTHER-KEYS.3

 DELETE.ALLOW-OTHER-KEYS.4 DELETE.ALLOW-OTHER-KEYS.5

 DELETE.ALLOW-OTHER-KEYS.6 DELETE.KEYWORDS.7 REMOVE.ERROR.1

 REMOVE.ERROR.2 REMOVE.ERROR.3 REMOVE.ERROR.4 REMOVE.ERROR.4A

 REMOVE.ERROR.5 REMOVE.ERROR.6 REMOVE.ERROR.7 REMOVE.ERROR.8

 REMOVE.ERROR.9 REMOVE.ERROR.10 REMOVE.ERROR.11 DELETE.ERROR.1

 DELETE.ERROR.2 DELETE.ERROR.3 DELETE.ERROR.4 DELETE.ERROR.5

 DELETE.ERROR.6 DELETE.ERROR.7 DELETE.ERROR.8 DELETE.ERROR.9

 DELETE.ERROR.10 DELETE.ERROR.11 REMOVE-IF-STRING.1 REMOVE-IF-STRING.2

 REMOVE-IF-STRING.3 REMOVE-IF-NOT-STRING.1 REMOVE-IF-NOT-STRING.2

 REMOVE-IF-NOT-STRING.3 DELETE-IF-STRING.1 DELETE-IF-STRING.2

 DELETE-IF-STRING.3 DELETE-IF-NOT-STRING.1 DELETE-IF-NOT-STRING.2

 DELETE-IF-NOT-STRING.3 RANDOM-REMOVE-DUPLICATES

 RANDOM-DELETE-DUPLICATES REMOVE-DUPLICATES.1 DELETE-DUPLICATES.1

 REMOVE-DUPLICATES.TEST-AND-TEST-NOT.1

 REMOVE-DUPLICATES.TEST-AND-TEST-NOT.2

 DELETE-DUPLICATES.TEST-AND-TEST-NOT.1

 DELETE-DUPLICATES.TEST-AND-TEST-NOT.2 REMOVE-DUPLICATES.FOLD.1

 REMOVE-DUPLICATES.FOLD.2 REMOVE-DUPLICATES.FOLD.3

 REMOVE-DUPLICATES.FOLD.4 REMOVE-DUPLICATES.ORDER.1

 REMOVE-DUPLICATES.ORDER.2 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.1

 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.2

 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.3

 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.4

 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.5

 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.6

 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.7

 REMOVE-DUPLICATES.ALLOW-OTHER-KEYS.8 REMOVE-DUPLICATES.KEYWORDS.1

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.1

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.2

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.3

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.4

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.5

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.6

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.7

 DELETE-DUPLICATES.ALLOW-OTHER-KEYS.8 DELETE-DUPLICATES.KEYWORDS.1

 DELETE-DUPLICATES.ORDER.1 DELETE-DUPLICATES.ORDER.2

 REMOVE-DUPLICATES.ERROR.1 REMOVE-DUPLICATES.ERROR.2

 REMOVE-DUPLICATES.ERROR.3 REMOVE-DUPLICATES.ERROR.4

 REMOVE-DUPLICATES.ERROR.5 REMOVE-DUPLICATES.ERROR.6

 REMOVE-DUPLICATES.ERROR.7 REMOVE-DUPLICATES.ERROR.8

 REMOVE-DUPLICATES.ERROR.9 REMOVE-DUPLICATES.ERROR.10

 DELETE-DUPLICATES.ERROR.1 DELETE-DUPLICATES.ERROR.2

 DELETE-DUPLICATES.ERROR.3 DELETE-DUPLICATES.ERROR.4

 DELETE-DUPLICATES.ERROR.5 DELETE-DUPLICATES.ERROR.6

 DELETE-DUPLICATES.ERROR.7 DELETE-DUPLICATES.ERROR.8

 DELETE-DUPLICATES.ERROR.9 DELETE-DUPLICATES.ERROR.10

 REMOVE-DUPLICATES.STRING.1 REMOVE-DUPLICATES.STRING.2

 DELETE-DUPLICATES.STRING.1 DELETE-DUPLICATES.STRING.2

 REMOVE-DUPLICATES.2 REMOVE-DUPLICATES.2A REMOVE-DUPLICATES.3

 REMOVE-DUPLICATES.3A REMOVE-DUPLICATES.4 REMOVE-DUPLICATES.5

 DELETE-DUPLICATES.2 DELETE-DUPLICATES.2A DELETE-DUPLICATES.3

 DELETE-DUPLICATES.3A DELETE-DUPLICATES.4 DELETE-DUPLICATES.5

 STRUCTURE-1-1 STRUCTURE-1-2 STRUCTURE-1-3 STRUCTURE-1-4 STRUCTURE-1-5

 STRUCTURE-1-6 STRUCTURE-1-7 STRUCTURE-1-8 STRUCTURE-1-9 STRUCTURE-1-10

 STRUCTURE-1-11 STRUCTURE-1-12 STRUCTURE-1-13 STRUCTURE-1-14

 STRUCTURE-1-15 STRUCTURE-2-1 STRUCTURE-2-2 STRUCTURE-2-3 STRUCTURE-2-4

 STRUCTURE-2-5 STRUCTURE-2-6 STRUCTURE-2-7 STRUCTURE-2-8

 STRUCT-TEST-03/1 STRUCT-TEST-03/2 STRUCT-TEST-03/ERROR.1

 STRUCT-TEST-03/ERROR.2 STRUCT-TEST-03/3 STRUCT-TEST-03/4

 STRUCT-TEST-03/5 STRUCT-TEST-03/ERROR.3 STRUCT-TEST-03/ERROR.4

 STRUCT-TEST-03/6 STRUCT-TEST-03/7 STRUCT-TEST-03/8

 STRUCT-TEST-03/ERROR.5 STRUCT-TEST-03/ERROR.6 STRUCT-TEST-03/9

 STRUCT-TEST-03/13 STRUCT-TEST-03/14 STRUCT-TEST-03/15 STRUCT-TEST-03/16

 STRUCT-TEST-03/17 STRUCT-TEST-03/15A STRUCT-TEST-03/15B

 STRUCT-TEST-03/20 STRUCT-TEST-04/1 STRUCT-TEST-04/2

 STRUCT-TEST-04/ERROR.1 STRUCT-TEST-04/ERROR.2 STRUCT-TEST-04/3

 STRUCT-TEST-04/4 STRUCT-TEST-04/5 STRUCT-TEST-04/ERROR.3

 STRUCT-TEST-04/ERROR.4 STRUCT-TEST-04/6 STRUCT-TEST-04/7

 STRUCT-TEST-04/8 STRUCT-TEST-04/ERROR.5 STRUCT-TEST-04/ERROR.6

 STRUCT-TEST-04/9 STRUCT-TEST-04/13 STRUCT-TEST-04/14 STRUCT-TEST-04/15

 STRUCT-TEST-04/16 STRUCT-TEST-04/17 STRUCT-TEST-04/15A

 STRUCT-TEST-04/15B STRUCT-TEST-04/20 STRUCT-TEST-05/1 STRUCT-TEST-05/2

 STRUCT-TEST-05/ERROR.1 STRUCT-TEST-05/ERROR.2 STRUCT-TEST-05/3

 STRUCT-TEST-05/4 STRUCT-TEST-05/5 STRUCT-TEST-05/ERROR.3

 STRUCT-TEST-05/ERROR.4 STRUCT-TEST-05/6 STRUCT-TEST-05/7

 STRUCT-TEST-05/8 STRUCT-TEST-05/ERROR.5 STRUCT-TEST-05/ERROR.6

 STRUCT-TEST-05/9 STRUCT-TEST-05/13 STRUCT-TEST-05/14 STRUCT-TEST-05/15

 STRUCT-TEST-05/16 STRUCT-TEST-05/17 STRUCT-TEST-05/15A

 STRUCT-TEST-05/15B STRUCT-TEST-05/20 STRUCT-TEST-06/1 STRUCT-TEST-06/2

 STRUCT-TEST-06/ERROR.1 STRUCT-TEST-06/ERROR.2 STRUCT-TEST-06/3

 STRUCT-TEST-06/4 STRUCT-TEST-06/5 STRUCT-TEST-06/ERROR.3

 STRUCT-TEST-06/ERROR.4 STRUCT-TEST-06/6 STRUCT-TEST-06/7

 STRUCT-TEST-06/8 STRUCT-TEST-06/ERROR.5 STRUCT-TEST-06/ERROR.6

 STRUCT-TEST-06/9 STRUCT-TEST-06/13 STRUCT-TEST-06/14 STRUCT-TEST-06/15

 STRUCT-TEST-06/16 STRUCT-TEST-06/17 STRUCT-TEST-06/15A

 STRUCT-TEST-06/15B STRUCT-TEST-06/20 STRUCT-TEST-07/1 STRUCT-TEST-07/2

 STRUCT-TEST-07/ERROR.1 STRUCT-TEST-07/ERROR.2 STRUCT-TEST-07/3

 STRUCT-TEST-07/4 STRUCT-TEST-07/5 STRUCT-TEST-07/ERROR.3

 STRUCT-TEST-07/ERROR.4 STRUCT-TEST-07/6 STRUCT-TEST-07/7

 STRUCT-TEST-07/8 STRUCT-TEST-07/ERROR.5 STRUCT-TEST-07/ERROR.6

 STRUCT-TEST-07/9 STRUCT-TEST-07/13 STRUCT-TEST-07/14 STRUCT-TEST-07/15

 STRUCT-TEST-07/16 STRUCT-TEST-07/17 STRUCT-TEST-07/15A

 STRUCT-TEST-07/15B STRUCT-TEST-07/20 STRUCT-TEST-08/1 STRUCT-TEST-08/2

 STRUCT-TEST-08/ERROR.1 STRUCT-TEST-08/ERROR.2 STRUCT-TEST-08/3

 STRUCT-TEST-08/4 STRUCT-TEST-08/5 STRUCT-TEST-08/ERROR.3

 STRUCT-TEST-08/ERROR.4 STRUCT-TEST-08/6 STRUCT-TEST-08/7

 STRUCT-TEST-08/8 STRUCT-TEST-08/ERROR.5 STRUCT-TEST-08/ERROR.6

 STRUCT-TEST-08/9 STRUCT-TEST-08/13 STRUCT-TEST-08/14 STRUCT-TEST-08/15

 STRUCT-TEST-08/16 STRUCT-TEST-08/17 STRUCT-TEST-08/15A

 STRUCT-TEST-08/15B STRUCT-TEST-08/20 STRUCT-TEST-09/1 STRUCT-TEST-09/2

 STRUCT-TEST-09/ERROR.1 STRUCT-TEST-09/ERROR.2 STRUCT-TEST-09/3

 STRUCT-TEST-09/4 STRUCT-TEST-09/5 STRUCT-TEST-09/ERROR.3

 STRUCT-TEST-09/ERROR.4 STRUCT-TEST-09/6 STRUCT-TEST-09/7

 STRUCT-TEST-09/8 STRUCT-TEST-09/ERROR.5 STRUCT-TEST-09/ERROR.6

 STRUCT-TEST-09/9 STRUCT-TEST-09/13 STRUCT-TEST-09/14 STRUCT-TEST-09/15

 STRUCT-TEST-09/16 STRUCT-TEST-09/17 STRUCT-TEST-09/15A

 STRUCT-TEST-09/15B STRUCT-TEST-09/20 STRUCT-TEST-10/1 STRUCT-TEST-10/2

 STRUCT-TEST-10/ERROR.1 STRUCT-TEST-10/ERROR.2 STRUCT-TEST-10/3

 STRUCT-TEST-10/4 STRUCT-TEST-10/5 STRUCT-TEST-10/ERROR.3

 STRUCT-TEST-10/ERROR.4 STRUCT-TEST-10/6 STRUCT-TEST-10/7

 STRUCT-TEST-10/8 STRUCT-TEST-10/ERROR.5 STRUCT-TEST-10/ERROR.6

 STRUCT-TEST-10/9 STRUCT-TEST-10/13 STRUCT-TEST-10/14 STRUCT-TEST-10/15

 STRUCT-TEST-10/16 STRUCT-TEST-10/17 STRUCT-TEST-10/15A

 STRUCT-TEST-10/15B STRUCT-TEST-10/20 STRUCT-TEST-11/1 STRUCT-TEST-11/2

 STRUCT-TEST-11/ERROR.1 STRUCT-TEST-11/ERROR.2 STRUCT-TEST-11/3

 STRUCT-TEST-11/4 STRUCT-TEST-11/5 STRUCT-TEST-11/ERROR.3

 STRUCT-TEST-11/ERROR.4 STRUCT-TEST-11/6 STRUCT-TEST-11/7

 STRUCT-TEST-11/8 STRUCT-TEST-11/ERROR.5 STRUCT-TEST-11/ERROR.6

 STRUCT-TEST-11/9 STRUCT-TEST-11/13 STRUCT-TEST-11/14 STRUCT-TEST-11/15

 STRUCT-TEST-11/16 STRUCT-TEST-11/17 STRUCT-TEST-11/15A

 STRUCT-TEST-11/15B STRUCT-TEST-11/20 STRUCT-TEST-12/1 STRUCT-TEST-12/2

 STRUCT-TEST-12/ERROR.1 STRUCT-TEST-12/ERROR.2 STRUCT-TEST-12/3

 STRUCT-TEST-12/4 STRUCT-TEST-12/5 STRUCT-TEST-12/ERROR.3

 STRUCT-TEST-12/ERROR.4 STRUCT-TEST-12/6 STRUCT-TEST-12/7

 STRUCT-TEST-12/8 STRUCT-TEST-12/ERROR.5 STRUCT-TEST-12/ERROR.6

 STRUCT-TEST-12/9 STRUCT-TEST-12/13 STRUCT-TEST-12/14 STRUCT-TEST-12/15

 STRUCT-TEST-12/16 STRUCT-TEST-12/17 STRUCT-TEST-12/15A

 STRUCT-TEST-12/15B STRUCT-TEST-12/20 STRUCT-TEST-13/1 STRUCT-TEST-13/2

 STRUCT-TEST-13/ERROR.1 STRUCT-TEST-13/ERROR.2 STRUCT-TEST-13/3

 STRUCT-TEST-13/4 STRUCT-TEST-13/5 STRUCT-TEST-13/ERROR.3

 STRUCT-TEST-13/ERROR.4 STRUCT-TEST-13/6 STRUCT-TEST-13/7

 STRUCT-TEST-13/8 STRUCT-TEST-13/ERROR.5 STRUCT-TEST-13/ERROR.6

 STRUCT-TEST-13/9 STRUCT-TEST-13/13 STRUCT-TEST-13/14 STRUCT-TEST-13/15

 STRUCT-TEST-13/16 STRUCT-TEST-13/17 STRUCT-TEST-13/15A

 STRUCT-TEST-13/15B STRUCT-TEST-13/20 STRUCT-TEST-14/1 STRUCT-TEST-14/2

 STRUCT-TEST-14/ERROR.1 STRUCT-TEST-14/ERROR.2 STRUCT-TEST-14/3

 STRUCT-TEST-14/4 STRUCT-TEST-14/5 STRUCT-TEST-14/ERROR.3

 STRUCT-TEST-14/ERROR.4 STRUCT-TEST-14/6 STRUCT-TEST-14/7

 STRUCT-TEST-14/8 STRUCT-TEST-14/ERROR.5 STRUCT-TEST-14/ERROR.6

 STRUCT-TEST-14/9 STRUCT-TEST-14/13 STRUCT-TEST-14/14 STRUCT-TEST-14/15

 STRUCT-TEST-14/16 STRUCT-TEST-14/17 STRUCT-TEST-14/15A

 STRUCT-TEST-14/15B STRUCT-TEST-14/20 STRUCT-TEST-15/1 STRUCT-TEST-15/4

 STRUCT-TEST-15/5 STRUCT-TEST-15/ERROR.3 STRUCT-TEST-15/ERROR.4

 STRUCT-TEST-15/6 STRUCT-TEST-15/7 STRUCT-TEST-15/8

 STRUCT-TEST-15/ERROR.5 STRUCT-TEST-15/ERROR.6 STRUCT-TEST-15/9

 STRUCT-TEST-15/10 STRUCT-TEST-15/13 STRUCT-TEST-15/14 STRUCT-TEST-15/15

 STRUCT-TEST-15/16 STRUCT-TEST-15/17 STRUCT-TEST-15/15A

 STRUCT-TEST-15/15B STRUCT-TEST-15/20 STRUCT-TEST-16/1 STRUCT-TEST-16/2

 STRUCT-TEST-16/ERROR.1 STRUCT-TEST-16/ERROR.2 STRUCT-TEST-16/3

 STRUCT-TEST-16/4 STRUCT-TEST-16/5 STRUCT-TEST-16/ERROR.3

 STRUCT-TEST-16/ERROR.4 STRUCT-TEST-16/6 STRUCT-TEST-16/7

 STRUCT-TEST-16/8 STRUCT-TEST-16/ERROR.5 STRUCT-TEST-16/ERROR.6

 STRUCT-TEST-16/9 STRUCT-TEST-16/13 STRUCT-TEST-16/14 STRUCT-TEST-16/15

 STRUCT-TEST-16/16 STRUCT-TEST-16/17 STRUCT-TEST-16/15A

 STRUCT-TEST-16/15B STRUCT-TEST-16/20 STRUCT-TEST-17/1 STRUCT-TEST-17/2

 STRUCT-TEST-17/ERROR.1 STRUCT-TEST-17/ERROR.2 STRUCT-TEST-17/3

 STRUCT-TEST-17/4 STRUCT-TEST-17/5 STRUCT-TEST-17/ERROR.3

 STRUCT-TEST-17/ERROR.4 STRUCT-TEST-17/6 STRUCT-TEST-17/7

 STRUCT-TEST-17/8 STRUCT-TEST-17/ERROR.5 STRUCT-TEST-17/ERROR.6

 STRUCT-TEST-17/9 STRUCT-TEST-17/10 STRUCT-TEST-17/13 STRUCT-TEST-17/14

 STRUCT-TEST-17/15 STRUCT-TEST-17/16 STRUCT-TEST-17/17

 STRUCT-TEST-17/15A STRUCT-TEST-17/15B STRUCT-TEST-17/20

 STRUCT-TEST-18/1 STRUCT-TEST-18/2 STRUCT-TEST-18/ERROR.1

 STRUCT-TEST-18/ERROR.2 STRUCT-TEST-18/3 STRUCT-TEST-18/4

 STRUCT-TEST-18/5 STRUCT-TEST-18/ERROR.3 STRUCT-TEST-18/ERROR.4

 STRUCT-TEST-18/6 STRUCT-TEST-18/7 STRUCT-TEST-18/8

 STRUCT-TEST-18/ERROR.5 STRUCT-TEST-18/ERROR.6 STRUCT-TEST-18/9

 STRUCT-TEST-18/13 STRUCT-TEST-18/14 STRUCT-TEST-18/15 STRUCT-TEST-18/16

 STRUCT-TEST-18/17 STRUCT-TEST-18/15A STRUCT-TEST-18/15B

 STRUCT-TEST-18/20 STRUCT-TEST-19/1 STRUCT-TEST-19/2

 STRUCT-TEST-19/ERROR.1 STRUCT-TEST-19/ERROR.2 STRUCT-TEST-19/3

 STRUCT-TEST-19/4 STRUCT-TEST-19/5 STRUCT-TEST-19/ERROR.3

 STRUCT-TEST-19/ERROR.4 STRUCT-TEST-19/6 STRUCT-TEST-19/7

 STRUCT-TEST-19/8 STRUCT-TEST-19/ERROR.5 STRUCT-TEST-19/ERROR.6

 STRUCT-TEST-19/9 STRUCT-TEST-19/13 STRUCT-TEST-19/14 STRUCT-TEST-19/15

 STRUCT-TEST-19/16 STRUCT-TEST-19/17 STRUCT-TEST-19/15A

 STRUCT-TEST-19/15B STRUCT-TEST-19/20 STRUCT-TEST-20/1 STRUCT-TEST-20/2

 STRUCT-TEST-20/ERROR.1 STRUCT-TEST-20/ERROR.2 STRUCT-TEST-20/3

 STRUCT-TEST-20/4 STRUCT-TEST-20/5 STRUCT-TEST-20/ERROR.3

 STRUCT-TEST-20/ERROR.4 STRUCT-TEST-20/6 STRUCT-TEST-20/7

 STRUCT-TEST-20/11 STRUCT-TEST-20/13 STRUCT-TEST-20/14 STRUCT-TEST-20/15

 STRUCT-TEST-20/16 STRUCT-TEST-20/17 STRUCT-TEST-20/15A

 STRUCT-TEST-20/15B STRUCT-TEST-20/20 STRUCT-TEST-21/1 STRUCT-TEST-21/2

 STRUCT-TEST-21/ERROR.1 STRUCT-TEST-21/ERROR.2 STRUCT-TEST-21/3

 STRUCT-TEST-21/4 STRUCT-TEST-21/5 STRUCT-TEST-21/ERROR.3

 STRUCT-TEST-21/ERROR.4 STRUCT-TEST-21/6 STRUCT-TEST-21/7

 STRUCT-TEST-21/8 STRUCT-TEST-21/ERROR.5 STRUCT-TEST-21/ERROR.6

 STRUCT-TEST-21/9 STRUCT-TEST-21/11 STRUCT-TEST-21/13 STRUCT-TEST-21/14

 STRUCT-TEST-21/15 STRUCT-TEST-21/16 STRUCT-TEST-21/17

 STRUCT-TEST-21/15A STRUCT-TEST-21/15B STRUCT-TEST-21/20

 STRUCT-TEST-22/1 STRUCT-TEST-22/2 STRUCT-TEST-22/ERROR.1

 STRUCT-TEST-22/ERROR.2 STRUCT-TEST-22/3 STRUCT-TEST-22/4

 STRUCT-TEST-22/5 STRUCT-TEST-22/ERROR.3 STRUCT-TEST-22/ERROR.4

 STRUCT-TEST-22/6 STRUCT-TEST-22/7 STRUCT-TEST-22/8

 STRUCT-TEST-22/ERROR.5 STRUCT-TEST-22/ERROR.6 STRUCT-TEST-22/9

 STRUCT-TEST-22/13 STRUCT-TEST-22/14 STRUCT-TEST-22/15 STRUCT-TEST-22/16

 STRUCT-TEST-22/17 STRUCT-TEST-22/15A STRUCT-TEST-22/15B

 STRUCT-TEST-22/20 STRUCT-TEST-23/1 STRUCT-TEST-23/2

 STRUCT-TEST-23/ERROR.1 STRUCT-TEST-23/ERROR.2 STRUCT-TEST-23/3

 STRUCT-TEST-23/4 STRUCT-TEST-23/5 STRUCT-TEST-23/ERROR.3

 STRUCT-TEST-23/ERROR.4 STRUCT-TEST-23/6 STRUCT-TEST-23/7

 STRUCT-TEST-23/8 STRUCT-TEST-23/ERROR.5 STRUCT-TEST-23/ERROR.6

 STRUCT-TEST-23/9 STRUCT-TEST-23/13 STRUCT-TEST-23/14 STRUCT-TEST-23/15

 STRUCT-TEST-23/16 STRUCT-TEST-23/17 STRUCT-TEST-23/15A

 STRUCT-TEST-23/15B STRUCT-TEST-23/20 STRUCT-TEST-24/1 STRUCT-TEST-24/2

 STRUCT-TEST-24/ERROR.1 STRUCT-TEST-24/ERROR.2 STRUCT-TEST-24/3

 STRUCT-TEST-24/4 STRUCT-TEST-24/5 STRUCT-TEST-24/ERROR.3

 STRUCT-TEST-24/ERROR.4 STRUCT-TEST-24/6 STRUCT-TEST-24/7

 STRUCT-TEST-24/8 STRUCT-TEST-24/ERROR.5 STRUCT-TEST-24/ERROR.6

 STRUCT-TEST-24/9 STRUCT-TEST-24/13 STRUCT-TEST-24/14 STRUCT-TEST-24/15

 STRUCT-TEST-24/16 STRUCT-TEST-24/17 STRUCT-TEST-24/15A

 STRUCT-TEST-24/15B STRUCT-TEST-24/20 STRUCT-TEST-25/1 STRUCT-TEST-25/2

 STRUCT-TEST-25/ERROR.1 STRUCT-TEST-25/ERROR.2 STRUCT-TEST-25/3

 STRUCT-TEST-25/4 STRUCT-TEST-25/5 STRUCT-TEST-25/ERROR.3

 STRUCT-TEST-25/ERROR.4 STRUCT-TEST-25/6 STRUCT-TEST-25/7

 STRUCT-TEST-25/8 STRUCT-TEST-25/ERROR.5 STRUCT-TEST-25/ERROR.6

 STRUCT-TEST-25/9 STRUCT-TEST-25/13 STRUCT-TEST-25/14 STRUCT-TEST-25/15

 STRUCT-TEST-25/16 STRUCT-TEST-25/17 STRUCT-TEST-25/15A

 STRUCT-TEST-25/15B STRUCT-TEST-25/20 STRUCT-TEST-26/1 STRUCT-TEST-26/2

 STRUCT-TEST-26/ERROR.1 STRUCT-TEST-26/ERROR.2 STRUCT-TEST-26/3

 STRUCT-TEST-26/4 STRUCT-TEST-26/5 STRUCT-TEST-26/ERROR.3

 STRUCT-TEST-26/ERROR.4 STRUCT-TEST-26/6 STRUCT-TEST-26/7

 STRUCT-TEST-26/8 STRUCT-TEST-26/ERROR.5 STRUCT-TEST-26/ERROR.6

 STRUCT-TEST-26/9 STRUCT-TEST-26/13 STRUCT-TEST-26/14 STRUCT-TEST-26/15

 STRUCT-TEST-26/16 STRUCT-TEST-26/17 STRUCT-TEST-26/15A

 STRUCT-TEST-26/15B STRUCT-TEST-26/20 STRUCT-TEST-27/1 STRUCT-TEST-27/2

 STRUCT-TEST-27/ERROR.1 STRUCT-TEST-27/ERROR.2 STRUCT-TEST-27/3

 STRUCT-TEST-27/4 STRUCT-TEST-27/5 STRUCT-TEST-27/ERROR.3

 STRUCT-TEST-27/ERROR.4 STRUCT-TEST-27/6 STRUCT-TEST-27/7

 STRUCT-TEST-27/8 STRUCT-TEST-27/ERROR.5 STRUCT-TEST-27/ERROR.6

 STRUCT-TEST-27/9 STRUCT-TEST-27/12 STRUCT-TEST-27/13 STRUCT-TEST-27/14

 STRUCT-TEST-27/15 STRUCT-TEST-27/16 STRUCT-TEST-27/17

 STRUCT-TEST-27/15A STRUCT-TEST-27/15B STRUCT-TEST-27/20

 STRUCT-TEST-28/1 STRUCT-TEST-28/2 STRUCT-TEST-28/ERROR.1

 STRUCT-TEST-28/ERROR.2 STRUCT-TEST-28/3 STRUCT-TEST-28/4

 STRUCT-TEST-28/5 STRUCT-TEST-28/ERROR.3 STRUCT-TEST-28/ERROR.4

 STRUCT-TEST-28/6 STRUCT-TEST-28/7 STRUCT-TEST-28/8

 STRUCT-TEST-28/ERROR.5 STRUCT-TEST-28/ERROR.6 STRUCT-TEST-28/9

 STRUCT-TEST-28/12 STRUCT-TEST-28/13 STRUCT-TEST-28/14 STRUCT-TEST-28/15

 STRUCT-TEST-28/16 STRUCT-TEST-28/17 STRUCT-TEST-28/15A

 STRUCT-TEST-28/15B STRUCT-TEST-28/20 STRUCT-TEST-29/1 STRUCT-TEST-29/2

 STRUCT-TEST-29/ERROR.1 STRUCT-TEST-29/ERROR.2 STRUCT-TEST-29/3

 STRUCT-TEST-29/4 STRUCT-TEST-29/5 STRUCT-TEST-29/ERROR.3

 STRUCT-TEST-29/ERROR.4 STRUCT-TEST-29/6 STRUCT-TEST-29/7

 STRUCT-TEST-29/8 STRUCT-TEST-29/ERROR.5 STRUCT-TEST-29/ERROR.6

 STRUCT-TEST-29/9 STRUCT-TEST-29/12 STRUCT-TEST-29/13 STRUCT-TEST-29/14

 STRUCT-TEST-29/15 STRUCT-TEST-29/16 STRUCT-TEST-29/17

 STRUCT-TEST-29/15A STRUCT-TEST-29/15B STRUCT-TEST-29/20

 STRUCT-TEST-30/1 STRUCT-TEST-30/2 STRUCT-TEST-30/ERROR.1

 STRUCT-TEST-30/ERROR.2 STRUCT-TEST-30/3 STRUCT-TEST-30/4

 STRUCT-TEST-30/5 STRUCT-TEST-30/ERROR.3 STRUCT-TEST-30/ERROR.4

 STRUCT-TEST-30/6 STRUCT-TEST-30/7 STRUCT-TEST-30/8

 STRUCT-TEST-30/ERROR.5 STRUCT-TEST-30/ERROR.6 STRUCT-TEST-30/9

 STRUCT-TEST-30/13 STRUCT-TEST-30/14 STRUCT-TEST-30/15 STRUCT-TEST-30/16

 STRUCT-TEST-30/17 STRUCT-TEST-30/15A STRUCT-TEST-30/15B

 STRUCT-TEST-30/20 STRUCT-TEST-31/1 STRUCT-TEST-31/2

 STRUCT-TEST-31/ERROR.1 STRUCT-TEST-31/ERROR.2 STRUCT-TEST-31/3

 STRUCT-TEST-31/4 STRUCT-TEST-31/5 STRUCT-TEST-31/ERROR.3

 STRUCT-TEST-31/ERROR.4 STRUCT-TEST-31/6 STRUCT-TEST-31/7

 STRUCT-TEST-31/8 STRUCT-TEST-31/ERROR.5 STRUCT-TEST-31/ERROR.6

 STRUCT-TEST-31/9 STRUCT-TEST-31/13 STRUCT-TEST-31/14 STRUCT-TEST-31/15

 STRUCT-TEST-31/16 STRUCT-TEST-31/17 STRUCT-TEST-31/15A

 STRUCT-TEST-31/15B STRUCT-TEST-31/20 STRUCT-TEST-32/1 STRUCT-TEST-32/2

 STRUCT-TEST-32/ERROR.1 STRUCT-TEST-32/ERROR.2 STRUCT-TEST-32/3

 STRUCT-TEST-32/4 STRUCT-TEST-32/5 STRUCT-TEST-32/ERROR.3

 STRUCT-TEST-32/ERROR.4 STRUCT-TEST-32/6 STRUCT-TEST-32/7

 STRUCT-TEST-32/8 STRUCT-TEST-32/ERROR.5 STRUCT-TEST-32/ERROR.6

 STRUCT-TEST-32/9 STRUCT-TEST-32/13 STRUCT-TEST-32/14 STRUCT-TEST-32/15

 STRUCT-TEST-32/16 STRUCT-TEST-32/17 STRUCT-TEST-32/15A

 STRUCT-TEST-32/15B STRUCT-TEST-32/20 STRUCT-TEST-33/1 STRUCT-TEST-33/2

 STRUCT-TEST-33/ERROR.1 STRUCT-TEST-33/ERROR.2 STRUCT-TEST-33/3

 STRUCT-TEST-33/4 STRUCT-TEST-33/5 STRUCT-TEST-33/ERROR.3

 STRUCT-TEST-33/ERROR.4 STRUCT-TEST-33/6 STRUCT-TEST-33/7

 STRUCT-TEST-33/8 STRUCT-TEST-33/ERROR.5 STRUCT-TEST-33/ERROR.6

 STRUCT-TEST-33/9 STRUCT-TEST-33/13 STRUCT-TEST-33/14 STRUCT-TEST-33/15

 STRUCT-TEST-33/16 STRUCT-TEST-33/17 STRUCT-TEST-33/15A

 STRUCT-TEST-33/15B STRUCT-TEST-33/20 STRUCT-TEST-34/1 STRUCT-TEST-34/2

 STRUCT-TEST-34/ERROR.1 STRUCT-TEST-34/ERROR.2 STRUCT-TEST-34/3

 STRUCT-TEST-34/4 STRUCT-TEST-34/5 STRUCT-TEST-34/ERROR.3

 STRUCT-TEST-34/ERROR.4 STRUCT-TEST-34/6 STRUCT-TEST-34/7

 STRUCT-TEST-34/8 STRUCT-TEST-34/ERROR.5 STRUCT-TEST-34/ERROR.6

 STRUCT-TEST-34/9 STRUCT-TEST-34/13 STRUCT-TEST-34/14 STRUCT-TEST-34/15

 STRUCT-TEST-34/16 STRUCT-TEST-34/17 STRUCT-TEST-34/15A

 STRUCT-TEST-34/15B STRUCT-TEST-34/20 STRUCT-TEST-35/1 STRUCT-TEST-35/2

 STRUCT-TEST-35/ERROR.1 STRUCT-TEST-35/ERROR.2 STRUCT-TEST-35/3

 STRUCT-TEST-35/4 STRUCT-TEST-35/5 STRUCT-TEST-35/ERROR.3

 STRUCT-TEST-35/ERROR.4 STRUCT-TEST-35/6 STRUCT-TEST-35/7

 STRUCT-TEST-35/8 STRUCT-TEST-35/ERROR.5 STRUCT-TEST-35/ERROR.6

 STRUCT-TEST-35/9 STRUCT-TEST-35/13 STRUCT-TEST-35/14 STRUCT-TEST-35/15

 STRUCT-TEST-35/16 STRUCT-TEST-35/17 STRUCT-TEST-35/15A

 STRUCT-TEST-35/15B STRUCT-TEST-35/20 STRUCT-TEST-36/1 STRUCT-TEST-36/2

 STRUCT-TEST-36/ERROR.1 STRUCT-TEST-36/ERROR.2 STRUCT-TEST-36/3

 STRUCT-TEST-36/4 STRUCT-TEST-36/5 STRUCT-TEST-36/ERROR.3

 STRUCT-TEST-36/ERROR.4 STRUCT-TEST-36/6 STRUCT-TEST-36/7

 STRUCT-TEST-36/8 STRUCT-TEST-36/ERROR.5 STRUCT-TEST-36/ERROR.6

 STRUCT-TEST-36/9 STRUCT-TEST-36/13 STRUCT-TEST-36/14 STRUCT-TEST-36/15

 STRUCT-TEST-36/16 STRUCT-TEST-36/17 STRUCT-TEST-36/15A

 STRUCT-TEST-36/15B STRUCT-TEST-36/20 STRUCT-TEST-37/1 STRUCT-TEST-37/5

 STRUCT-TEST-37/ERROR.3 STRUCT-TEST-37/ERROR.4 STRUCT-TEST-37/6

 STRUCT-TEST-37/7 STRUCT-TEST-37/8 STRUCT-TEST-37/ERROR.5

 STRUCT-TEST-37/ERROR.6 STRUCT-TEST-37/9 STRUCT-TEST-37/10

 STRUCTURE-37-1 STRUCT-TEST-38/1 STRUCT-TEST-38/2 STRUCT-TEST-38/ERROR.1

 STRUCT-TEST-38/ERROR.2 STRUCT-TEST-38/3 STRUCT-TEST-38/5

 STRUCT-TEST-38/ERROR.3 STRUCT-TEST-38/ERROR.4 STRUCT-TEST-38/6

 STRUCT-TEST-38/7 STRUCT-TEST-38/8 STRUCT-TEST-38/ERROR.5

 STRUCT-TEST-38/ERROR.6 STRUCT-TEST-38/9 STRUCTURE-38-1 STRUCT-TEST-39/1

 STRUCT-TEST-39/5 STRUCT-TEST-39/ERROR.3 STRUCT-TEST-39/ERROR.4

 STRUCT-TEST-39/6 STRUCT-TEST-39/7 STRUCT-TEST-39/8

 STRUCT-TEST-39/ERROR.5 STRUCT-TEST-39/ERROR.6 STRUCT-TEST-39/9

 STRUCT-TEST-39/10 STRUCTURE-39-1 STRUCT-TEST-40/1 STRUCT-TEST-40/5

 STRUCT-TEST-40/ERROR.3 STRUCT-TEST-40/ERROR.4 STRUCT-TEST-40/6

 STRUCT-TEST-40/7 STRUCT-TEST-40/8 STRUCT-TEST-40/ERROR.5

 STRUCT-TEST-40/ERROR.6 STRUCT-TEST-40/9 STRUCT-TEST-40/10

 STRUCT-TEST-41/1 STRUCT-TEST-41/2 STRUCT-TEST-41/ERROR.1

 STRUCT-TEST-41/ERROR.2 STRUCT-TEST-41/3 STRUCT-TEST-41/5

 STRUCT-TEST-41/ERROR.3 STRUCT-TEST-41/ERROR.4 STRUCT-TEST-41/6

 STRUCT-TEST-41/7 STRUCT-TEST-41/8 STRUCT-TEST-41/ERROR.5

 STRUCT-TEST-41/ERROR.6 STRUCT-TEST-41/9 STRUCT-TEST-42/1

 STRUCT-TEST-42/5 STRUCT-TEST-42/ERROR.3 STRUCT-TEST-42/ERROR.4

 STRUCT-TEST-42/6 STRUCT-TEST-42/7 STRUCT-TEST-42/8

 STRUCT-TEST-42/ERROR.5 STRUCT-TEST-42/ERROR.6 STRUCT-TEST-42/9

 STRUCT-TEST-42/10 STRUCT-TEST-43/1 STRUCT-TEST-43/2

 STRUCT-TEST-43/ERROR.1 STRUCT-TEST-43/ERROR.2 STRUCT-TEST-43/3

 STRUCT-TEST-43/5 STRUCT-TEST-43/ERROR.3 STRUCT-TEST-43/ERROR.4

 STRUCT-TEST-43/6 STRUCT-TEST-43/7 STRUCT-TEST-43/8

 STRUCT-TEST-43/ERROR.5 STRUCT-TEST-43/ERROR.6 STRUCT-TEST-43/9

 STRUCT-TEST-44/1 STRUCT-TEST-44/5 STRUCT-TEST-44/ERROR.3

 STRUCT-TEST-44/ERROR.4 STRUCT-TEST-44/6 STRUCT-TEST-44/7

 STRUCT-TEST-44/8 STRUCT-TEST-44/ERROR.5 STRUCT-TEST-44/ERROR.6

 STRUCT-TEST-44/9 STRUCT-TEST-44/10 STRUCTS-ARE-DISJOINT

 STRUCT-TEST-45/1 STRUCT-TEST-45/5 STRUCT-TEST-45/ERROR.3

 STRUCT-TEST-45/ERROR.4 STRUCT-TEST-45/6 STRUCT-TEST-45/7

 STRUCT-TEST-45/8 STRUCT-TEST-45/ERROR.5 STRUCT-TEST-45/ERROR.6

 STRUCT-TEST-45/9 STRUCT-TEST-45/10 STRUCTURE-45-1 STRUCT-TEST-46/1

 STRUCT-TEST-46/5 STRUCT-TEST-46/ERROR.3 STRUCT-TEST-46/ERROR.4

 STRUCT-TEST-46/6 STRUCT-TEST-46/7 STRUCT-TEST-46/8

 STRUCT-TEST-46/ERROR.5 STRUCT-TEST-46/ERROR.6 STRUCT-TEST-46/9

 STRUCT-TEST-46/10 STRUCTURE-46-1 STRUCT-TEST-47/1 STRUCT-TEST-47/5

 STRUCT-TEST-47/ERROR.3 STRUCT-TEST-47/ERROR.4 STRUCT-TEST-47/6

 STRUCT-TEST-47/7 STRUCT-TEST-47/8 STRUCT-TEST-47/ERROR.5

 STRUCT-TEST-47/ERROR.6 STRUCT-TEST-47/9 STRUCT-TEST-47/10

 STRUCTURE-47-1 STRUCT-TEST-48/1 STRUCT-TEST-48/5 STRUCT-TEST-48/ERROR.3

 STRUCT-TEST-48/ERROR.4 STRUCT-TEST-48/6 STRUCT-TEST-48/7

 STRUCT-TEST-48/8 STRUCT-TEST-48/ERROR.5 STRUCT-TEST-48/ERROR.6

 STRUCT-TEST-48/9 STRUCT-TEST-48/10 STRUCTURE-48-1 STRUCT-TEST-49/1

 STRUCT-TEST-49/5 STRUCT-TEST-49/ERROR.3 STRUCT-TEST-49/ERROR.4

 STRUCT-TEST-49/6 STRUCT-TEST-49/7 STRUCT-TEST-49/8

 STRUCT-TEST-49/ERROR.5 STRUCT-TEST-49/ERROR.6 STRUCT-TEST-49/9

 STRUCT-TEST-49/10 STRUCT-TEST-50/1 STRUCT-TEST-50/5

 STRUCT-TEST-50/ERROR.3 STRUCT-TEST-50/ERROR.4 STRUCT-TEST-50/6

 STRUCT-TEST-50/7 STRUCT-TEST-50/8 STRUCT-TEST-50/ERROR.5

 STRUCT-TEST-50/ERROR.6 STRUCT-TEST-50/9 STRUCT-TEST-50/10

 STRUCT-TEST-51/1 STRUCT-TEST-51/5 STRUCT-TEST-51/ERROR.3

 STRUCT-TEST-51/ERROR.4 STRUCT-TEST-51/6 STRUCT-TEST-51/7

 STRUCT-TEST-51/8 STRUCT-TEST-51/ERROR.5 STRUCT-TEST-51/ERROR.6

 STRUCT-TEST-51/9 STRUCT-TEST-51/10 STRUCT-TEST-52/1 STRUCT-TEST-52/5

 STRUCT-TEST-52/ERROR.3 STRUCT-TEST-52/ERROR.4 STRUCT-TEST-52/6

 STRUCT-TEST-52/7 STRUCT-TEST-52/8 STRUCT-TEST-52/ERROR.5

 STRUCT-TEST-52/ERROR.6 STRUCT-TEST-52/9 STRUCT-TEST-52/10

 STRUCT-TEST-53/1 STRUCT-TEST-53/5 STRUCT-TEST-53/ERROR.3

 STRUCT-TEST-53/ERROR.4 STRUCT-TEST-53/6 STRUCT-TEST-53/7

 STRUCT-TEST-53/8 STRUCT-TEST-53/ERROR.5 STRUCT-TEST-53/ERROR.6

 STRUCT-TEST-53/9 STRUCT-TEST-53/10 STRUCT-TEST-53/18 STRUCTURE-53-1

 STRUCT-TEST-54/1 STRUCT-TEST-54/5 STRUCT-TEST-54/ERROR.3

 STRUCT-TEST-54/ERROR.4 STRUCT-TEST-54/6 STRUCT-TEST-54/7

 STRUCT-TEST-54/8 STRUCT-TEST-54/ERROR.5 STRUCT-TEST-54/ERROR.6

 STRUCT-TEST-54/9 STRUCT-TEST-54/10 STRUCT-TEST-54/18 STRUCTURE-54-1

 STRUCT-TEST-55/1 STRUCT-TEST-55/2 STRUCT-TEST-55/ERROR.1

 STRUCT-TEST-55/ERROR.2 STRUCT-TEST-55/3 STRUCT-TEST-55/5

 STRUCT-TEST-55/ERROR.3 STRUCT-TEST-55/ERROR.4 STRUCT-TEST-55/6

 STRUCT-TEST-55/7 STRUCT-TEST-55/8 STRUCT-TEST-55/ERROR.5

 STRUCT-TEST-55/ERROR.6 STRUCT-TEST-55/9 STRUCTURE-55-1 STRUCT-TEST-56/1

 STRUCT-TEST-56/2 STRUCT-TEST-56/ERROR.1 STRUCT-TEST-56/ERROR.2

 STRUCT-TEST-56/3 STRUCT-TEST-56/5 STRUCT-TEST-56/ERROR.3

 STRUCT-TEST-56/ERROR.4 STRUCT-TEST-56/6 STRUCT-TEST-56/7

 STRUCT-TEST-56/8 STRUCT-TEST-56/ERROR.5 STRUCT-TEST-56/ERROR.6

 STRUCT-TEST-56/9 STRUCTURE-56-1 STRUCT-TEST-57/1 STRUCT-TEST-57/2

 STRUCT-TEST-57/ERROR.1 STRUCT-TEST-57/ERROR.2 STRUCT-TEST-57/3

 STRUCT-TEST-57/4 STRUCT-TEST-57/5 STRUCT-TEST-57/ERROR.3

 STRUCT-TEST-57/ERROR.4 STRUCT-TEST-57/6 STRUCT-TEST-57/7

 STRUCT-TEST-57/8 STRUCT-TEST-57/ERROR.5 STRUCT-TEST-57/ERROR.6

 STRUCT-TEST-57/9 STRUCT-TEST-57/13 STRUCT-TEST-57/14 STRUCT-TEST-57/15

 STRUCT-TEST-57/16 STRUCT-TEST-57/17 STRUCT-TEST-57/15A

 STRUCT-TEST-57/15B STRUCT-TEST-57/20 STRUCT-TEST-58/1 STRUCT-TEST-58/2

 STRUCT-TEST-58/ERROR.1 STRUCT-TEST-58/ERROR.2 STRUCT-TEST-58/3

 STRUCT-TEST-58/4 STRUCT-TEST-58/5 STRUCT-TEST-58/ERROR.3

 STRUCT-TEST-58/ERROR.4 STRUCT-TEST-58/6 STRUCT-TEST-58/7

 STRUCT-TEST-58/8 STRUCT-TEST-58/ERROR.5 STRUCT-TEST-58/ERROR.6

 STRUCT-TEST-58/9 STRUCT-TEST-58/13 STRUCT-TEST-58/14 STRUCT-TEST-58/15

 STRUCT-TEST-58/16 STRUCT-TEST-58/17 STRUCT-TEST-58/15A

 STRUCT-TEST-58/15B STRUCT-TEST-58/18 STRUCT-TEST-58/19

 STRUCT-TEST-58/20 STRUCT-TEST-59/1 STRUCT-TEST-59/2

 STRUCT-TEST-59/ERROR.1 STRUCT-TEST-59/ERROR.2 STRUCT-TEST-59/3

 STRUCT-TEST-59/4 STRUCT-TEST-59/5 STRUCT-TEST-59/ERROR.3

 STRUCT-TEST-59/ERROR.4 STRUCT-TEST-59/6 STRUCT-TEST-59/7

 STRUCT-TEST-59/8 STRUCT-TEST-59/ERROR.5 STRUCT-TEST-59/ERROR.6

 STRUCT-TEST-59/9 STRUCT-TEST-59/13 STRUCT-TEST-59/14 STRUCT-TEST-59/15

 STRUCT-TEST-59/16 STRUCT-TEST-59/17 STRUCT-TEST-59/15A

 STRUCT-TEST-59/15B STRUCT-TEST-59/18 STRUCT-TEST-59/19

 STRUCT-TEST-59/20 STRUCT-TEST-60/1 STRUCT-TEST-60/2

 STRUCT-TEST-60/ERROR.1 STRUCT-TEST-60/ERROR.2 STRUCT-TEST-60/3

 STRUCT-TEST-60/4 STRUCT-TEST-60/5 STRUCT-TEST-60/ERROR.3

 STRUCT-TEST-60/ERROR.4 STRUCT-TEST-60/6 STRUCT-TEST-60/7

 STRUCT-TEST-60/8 STRUCT-TEST-60/ERROR.5 STRUCT-TEST-60/ERROR.6

 STRUCT-TEST-60/9 STRUCT-TEST-60/13 STRUCT-TEST-60/14 STRUCT-TEST-60/15

 STRUCT-TEST-60/16 STRUCT-TEST-60/17 STRUCT-TEST-60/15A

 STRUCT-TEST-60/15B STRUCT-TEST-60/20 STRUCTURE-60-1 STRUCTURE-61-1

 STRUCTURE-62-1 STRUCTURE-62-2 STRUCT-TEST-63/1 STRUCT-TEST-63/2

 STRUCT-TEST-63/ERROR.1 STRUCT-TEST-63/ERROR.2 STRUCT-TEST-63/3

 STRUCT-TEST-63/4 STRUCT-TEST-63/5 STRUCT-TEST-63/ERROR.3

 STRUCT-TEST-63/ERROR.4 STRUCT-TEST-63/6 STRUCT-TEST-63/7

 STRUCT-TEST-63/8 STRUCT-TEST-63/ERROR.5 STRUCT-TEST-63/ERROR.6

 STRUCT-TEST-63/9 STRUCT-TEST-63/13 STRUCT-TEST-63/14 STRUCT-TEST-63/15

 STRUCT-TEST-63/16 STRUCT-TEST-63/17 STRUCT-TEST-63/15A

 STRUCT-TEST-63/15B STRUCT-TEST-63/20 STRUCT-TEST-64/1 STRUCT-TEST-64/2

 STRUCT-TEST-64/ERROR.1 STRUCT-TEST-64/ERROR.2 STRUCT-TEST-64/3

 STRUCT-TEST-64/4 STRUCT-TEST-64/5 STRUCT-TEST-64/ERROR.3

 STRUCT-TEST-64/ERROR.4 STRUCT-TEST-64/6 STRUCT-TEST-64/7

 STRUCT-TEST-64/8 STRUCT-TEST-64/ERROR.5 STRUCT-TEST-64/ERROR.6

 STRUCT-TEST-64/9 STRUCT-TEST-64/13 STRUCT-TEST-64/14 STRUCT-TEST-64/15

 STRUCT-TEST-64/16 STRUCT-TEST-64/17 STRUCT-TEST-64/15A

 STRUCT-TEST-64/15B STRUCT-TEST-64/20 STRUCT-TEST-65/1 STRUCT-TEST-65/2

 STRUCT-TEST-65/ERROR.1 STRUCT-TEST-65/ERROR.2 STRUCT-TEST-65/3

 STRUCT-TEST-65/4 STRUCT-TEST-65/5 STRUCT-TEST-65/ERROR.3

 STRUCT-TEST-65/ERROR.4 STRUCT-TEST-65/6 STRUCT-TEST-65/7

 STRUCT-TEST-65/8 STRUCT-TEST-65/ERROR.5 STRUCT-TEST-65/ERROR.6

 STRUCT-TEST-65/9 STRUCT-TEST-65/13 STRUCT-TEST-65/14 STRUCT-TEST-65/15

 STRUCT-TEST-65/16 STRUCT-TEST-65/17 STRUCT-TEST-65/15A

 STRUCT-TEST-65/15B STRUCT-TEST-65/20 STRUCT-TEST-66/1 STRUCT-TEST-66/2

 STRUCT-TEST-66/ERROR.1 STRUCT-TEST-66/ERROR.2 STRUCT-TEST-66/3

 STRUCT-TEST-66/4 STRUCT-TEST-66/5 STRUCT-TEST-66/ERROR.3

 STRUCT-TEST-66/ERROR.4 STRUCT-TEST-66/6 STRUCT-TEST-66/7

 STRUCT-TEST-66/8 STRUCT-TEST-66/ERROR.5 STRUCT-TEST-66/ERROR.6

 STRUCT-TEST-66/9 STRUCT-TEST-66/13 STRUCT-TEST-66/14 STRUCT-TEST-66/15

 STRUCT-TEST-66/16 STRUCT-TEST-66/17 STRUCT-TEST-66/15A

 STRUCT-TEST-66/15B STRUCT-TEST-66/20 STRUCT-TEST-67/1 STRUCT-TEST-67/2

 STRUCT-TEST-67/ERROR.1 STRUCT-TEST-67/ERROR.2 STRUCT-TEST-67/3

 STRUCT-TEST-67/4 STRUCT-TEST-67/5 STRUCT-TEST-67/ERROR.3

 STRUCT-TEST-67/ERROR.4 STRUCT-TEST-67/6 STRUCT-TEST-67/7

 STRUCT-TEST-67/8 STRUCT-TEST-67/ERROR.5 STRUCT-TEST-67/ERROR.6

 STRUCT-TEST-67/9 STRUCT-TEST-67/13 STRUCT-TEST-67/14 STRUCT-TEST-67/15

 STRUCT-TEST-67/16 STRUCT-TEST-67/17 STRUCT-TEST-67/15A

 STRUCT-TEST-67/15B STRUCT-TEST-67/20 STRUCT-TEST-68/1 STRUCT-TEST-68/2

 STRUCT-TEST-68/ERROR.1 STRUCT-TEST-68/ERROR.2 STRUCT-TEST-68/3

 STRUCT-TEST-68/4 STRUCT-TEST-68/5 STRUCT-TEST-68/ERROR.3

 STRUCT-TEST-68/ERROR.4 STRUCT-TEST-68/6 STRUCT-TEST-68/7

 STRUCT-TEST-68/8 STRUCT-TEST-68/ERROR.5 STRUCT-TEST-68/ERROR.6

 STRUCT-TEST-68/9 STRUCT-TEST-68/13 STRUCT-TEST-68/14 STRUCT-TEST-68/15

 STRUCT-TEST-68/16 STRUCT-TEST-68/17 STRUCT-TEST-68/15A

 STRUCT-TEST-68/15B STRUCT-TEST-68/20 COPY-STRUCTURE.ERROR.1

 COPY-STRUCTURE.ERROR.2 STRUCTURE-BOA-TEST-01/1 STRUCTURE-BOA-TEST-02/1

 STRUCTURE-BOA-TEST-02/2 STRUCTURE-BOA-TEST-02/3 STRUCTURE-BOA-TEST-03/1

 STRUCTURE-BOA-TEST-03/2 STRUCTURE-BOA-TEST-04/1 STRUCTURE-BOA-TEST-04/2

 STRUCTURE-BOA-TEST-05/1 STRUCTURE-BOA-TEST-05/2 STRUCTURE-BOA-TEST-05/3

 STRUCTURE-BOA-TEST-05/4 STRUCTURE-BOA-TEST-06/1 STRUCTURE-BOA-TEST-06/2

 STRUCTURE-BOA-TEST-06/3 STRUCTURE-BOA-TEST-06/4 STRUCTURE-BOA-TEST-07/1

 STRUCTURE-BOA-TEST-07/2 STRUCTURE-BOA-TEST-07/3 STRUCTURE-BOA-TEST-07/4

 STRUCTURE-BOA-TEST-08/1 STRUCTURE-BOA-TEST-09/1 STRUCTURE-BOA-TEST-09/2

 STRUCTURE-BOA-TEST-09/3 STRUCTURE-BOA-TEST-09/4 STRUCTURE-BOA-TEST-09/5

 STRUCTURE-BOA-TEST-09/6 STRUCTURE-BOA-TEST-09/7 STRUCTURE-BOA-TEST-10/1

 STRUCTURE-BOA-TEST-11/1 STRUCTURE-BOA-12/1 STRUCTURE-BOA-12/2

 STRUCTURE-BOA-12/3 STRUCTURE-BOA-TEST-13/1 STRUCTURE-BOA-TEST-13/2

 STRUCTURE-BOA-TEST-13/3 STRUCTURE-BOA-TEST-13/4 STRUCTURE-BOA-TEST-13/5

 STRUCTURE-BOA-TEST-13/6 STRUCTURE-BOA-TEST-13/7 STRUCTURE-BOA-TEST-13/8

 STRUCTURE-BOA-TEST-14/1 STRUCTURE-BOA-TEST-14/2 STRUCTURE-BOA-TEST-14/3

 STRUCTURE-BOA-TEST-14/4 STRUCTURE-BOA-TEST-14/5 STRUCTURE-BOA-TEST-15/1

 STRUCTURE-BOA-TEST-15/2 STRUCTURE-BOA-TEST-15/3 STRUCTURE-BOA-TEST-15/4

 STRUCTURE-BOA-TEST-15/5 STRUCTURE-BOA-TEST-15/6 STRUCTURE-BOA-TEST-15/7

 STRUCTURE-BOA-TEST-15/8 STRUCTURE-BOA-TEST-16/1 STRUCTURE-BOA-TEST-16/2

 STRUCTURE-BOA-TEST-16/3 STRUCTURE-BOA-TEST-16/4 STRUCTURE-BOA-TEST-16/5

 STRUCTURE-BOA-TEST-16/6 STRUCTURE-BOA-TEST-16/7 STRUCTURE-BOA-TEST-16/8

 STRUCTURE-BOA-TEST-16/10 STRUCTURE-BOA-TEST-16/11 STRUCT.ERROR.1

 STRUCT-INCLUDE.1 STRUCT-INCLUDE.2 STRUCT-INCLUDE.3 STRUCT-INCLUDE.4

 STRUCT-INCLUDE.5 STRUCT-INCLUDE.5A STRUCT-INCLUDE.6 STRUCT-INCLUDE.7

 BOOLEAN-TYPE.1 BOOLEAN-TYPE.2 BOOLEAN-TYPE.3 TYPES.3 TYPES.6 TYPES.7B

 TYPES.7C TYPES.8 TYPES.9 TYPES.9A

 ALL-CLASSES-ARE-TYPE-EQUIVALENT-TO-THEIR-NAMES

 ALL-CLASSES-ARE-TYPE-EQUIVALENT-TO-THEIR-NAMES.2

 ALL-STANDARD-CLASSES-ARE-SUBTYPES-OF-STANDARD-OBJECT

 ALL-STANDARD-CLASSES-ARE-SUBTYPES-OF-STANDARD-OBJECT.2

 ALL-STRUCTURE-CLASSES-ARE-SUBTYPES-OF-STRUCTURE-OBJECT

 ALL-STRUCTURE-CLASSES-ARE-SUBTYPES-OF-STRUCTURE-OBJECT.2

 ALL-EXPORTED-CL-CLASS-NAMES-ARE-VALID

Test ALL-STANDARD-GENERIC-FUNCTIONS-ARE-INSTANCES-OF-THAT-CLASS failed

Form: (LOOP FOR

            SYM

            IN

            *CL-STANDARD-GENERIC-FUNCTION-SYMBOLS*

            FOR

            FUN

            =

            (AND (FBOUNDP SYM) (SYMBOL-FUNCTION SYM))

            UNLESS

            (AND (TYPEP FUN 'GENERIC-FUNCTION)

                 (TYPEP FUN 'STANDARD-GENERIC-FUNCTION))

            COLLECT

            (LIST SYM FUN))

Expected value: NIL

Actual value: ((COMPUTE-APPLICABLE-METHODS

                #<compiled-function COMPUTE-APPLICABLE-METHODS>)

               (FIND-METHOD #<compiled-function FIND-METHOD>)

               (FUNCTION-KEYWORDS #<compiled-function FUNCTION-KEYWORDS>)

               (METHOD-QUALIFIERS #<compiled-function METHOD-QUALIFIERS>)

               (REMOVE-METHOD #<compiled-function REMOVE-METHOD>)).

 STRUCTURE-OBJECT-IS-IN-STRUCTURE-CLASS

 STANDARD-OBJECT-IS-IN-STANDARD-CLASS TYPE-AND-CLASS-FNS

 TYPE-AND-CLASS-MACROS TYPE-ERROR-DATUM.1 TYPE-ERROR-EXPECTED-TYPE.1

 TYPE-ERROR-DATUM.ERROR.1 TYPE-ERROR-DATUM.ERROR.2

 TYPE-ERROR-EXPECTED-TYPE.ERROR.1 TYPE-ERROR-EXPECTED-TYPE.ERROR.2

 TYPE-OR-NOT-TYPE-IS-EVERYTHING USER-CLASS-DISJOINTNESS

 USER-CLASS-DISJOINTNESS-2 USER-STRUCT-DISJOINTNESS

 USER-STRUCT-DISJOINTNESS-2 TAC-3.1 TAC-3.2 TAC-3.3 TAC-3.4 TAC-3.5

 TAC-3.6 TAC-3.7 TAC-3.8 TAC-3.9 TAC-3.10 TAC-3.11 TAC-3.12 TAC-3.13

 TAC-3.14 TAC-3.15 TAC-3.16 TAC-3.17

 UNIVERSE-ELEMENTS-IN-AT-MOST-ONE-DISJOINT-TYPE

 INTEGER-AND-RATIO-ARE-DISJOINT BIGNUM-AND-RATIO-ARE-DISJOINT

 BIGNUM-AND-FIXNUM-ARE-DISJOINT FIXNUM-AND-RATIO-ARE-DISJOINT

 BYTE8-AND-RATIO-ARE-DISJOINT BIT-AND-RATIO-ARE-DISJOINT

 INTEGER-AND-FLOAT-ARE-DISJOINT RATIO-AND-FLOAT-ARE-DISJOINT

 COMPLEX-AND-FLOAT-ARE-DISJOINT INTEGER-SUBRANGES-ARE-DISJOINT

 KEYWORD-AND-NULL-ARE-DISJOINT KEYWORD-AND-BOOLEAN-ARE-DISJOINT COERCE.1

 COERCE.2 COERCE.3 COERCE.4 COERCE.5 COERCE.6 COERCE.7 COERCE.8 COERCE.9

 COERCE.10 COERCE.11 COERCE.12 COERCE.13 COERCE.14 COERCE.15 COERCE.16

 COERCE.17 COERCE.18 COERCE.19 COERCE.20 COERCE.21 COERCE.22

 COERCE.ORDER.1 COERCE.FOLD.1 COERCE.FOLD.2 COERCE.FOLD.3 COERCE.ERROR.2

 COERCE.ERROR.3 COERCE.ERROR.4 COERCE.ERROR.5 COERCE.ERROR.6

 COERCE.ERROR.7 COERCE.ERROR.8 COERCE.ERROR.9 COERCE.ERROR.10

 SUBTYPEP.ORDER.1 SIMPLE-BASE-STRING-IS-SEQUENCE SUBTYPE.ENV.1

 SUBTYPE.ENV.2 SUBTYPE.ENV.3 SUBTYPE.ENV.4 SUBTYPE.ENV.5

 SUBTYPEP.ERROR.1 SUBTYPEP.ERROR.2 SUBTYPEP.ERROR.3

 KEYWORD-IS-SUBTYPE-OF-ATOM RATIO-IS-SUBTYPE-OF-ATOM

 EXTENDED-CHAR-IS-SUBTYPE-OF-ATOM STRING-IS-NOT-SIMPLE-VECTOR

 BASE-STRING-IS-NOT-SIMPLE-VECTOR SIMPLE-STRING-IS-NOT-SIMPLE-VECTOR

 SIMPLE-BASE-STRING-IS-NOT-SIMPLE-VECTOR BIT-VECTOR-IS-NOT-SIMPLE-VECTOR

 SIMPLE-BIT-VECTOR-IS-NOT-SIMPLE-VECTOR SUBTYPEP.EXTENDED-CHAR.1

 SUBTYPEP.EXTENDED-CHAR.2 SUBTYPEP.EXTENDED-CHAR.3 SUBTYPEP.AND/OR.1

 SUBTYPEP.AND/OR.2 SUBTYPEP.AND.1 SUBTYPEP.OR.1 SUBTYPEP.AND.2

 SUBTYPEP.OR.2 SUBTYPEP.AND.3 SUBTYPEP.OR.3 SUBTYPEP.AND.4 SUBTYPEP.OR.4

 SUBTYPEP.NIL.1 SUBTYPEP.NIL.2 SUBTYPEP.FIXNUM-OR-BIGNUM

 SUBTYPEP.FIXNUM.INTEGER SUBTYPEP.BIGNUM.INTEGER SUBTYPEP.INTEGER.1

 SUBTYPEP.INTEGER.2 SUBTYPEP.INTEGER.3 SUBTYPEP.INTEGER.3A

 SUBTYPEP.INTEGER.3B SUBTYPEP.INTEGER.3C SUBTYPEP.INTEGER.4

 SUBTYPEP.INTEGER.4A SUBTYPEP.INTEGER.4B SUBTYPEP.INTEGER.4C

 SUBTYPEP.INTEGER.5 SUBTYPEP.INTEGER.5A SUBTYPEP.INTEGER.5B

 SUBTYPEP.INTEGER.5C SUBTYPEP.INTEGER.6 SUBTYPEP.INTEGER.6A

 SUBTYPEP.INTEGER.6B SUBTYPEP.INTEGER.6C SUBTYPEP.INTEGER.7

 SUBTYPEP.INTEGER.7A SUBTYPEP.INTEGER.7B SUBTYPEP.INTEGER.7C

 SUBTYPEP.INTEGER.8 SUBTYPEP.INTEGER.8A SUBTYPEP.INTEGER.8B

 SUBTYPEP.INTEGER.8C SUBTYPEP.INTEGER.9 SUBTYPEP.INTEGER.9A

 SUBTYPEP.INTEGER.9B SUBTYPEP.INTEGER.9C SUBTYPEP.INTEGER.10

 SUBTYPEP.INTEGER.10A SUBTYPEP.INTEGER.10B SUBTYPEP.INTEGER.10C

 SUBTYPEP.INTEGER.11 SUBTYPEP.INTEGER.12 SUBTYPEP.INTEGER.13

 SUBTYPEP.INTEGER.14 SUBTYPEP.INTEGER.15 SUBTYPEP.INTEGER.16

 SUBTYPEP.INTEGER.17 SUBTYPEP.INTEGER.18 SUBTYPEP.INTEGER.19

 SUBTYPEP.INTEGER.20 SUBTYPEP.INTEGER.21 SUBTYPEP.INTEGER.22

 SUBTYPEP.INTEGER.23 SUBTYPEP.INTEGER.24 SUBTYPEP.INTEGER.25

 SUBTYPEP.INTEGER.26 SUBTYPEP.INTEGER.27 SUBTYPEP.INTEGER.28

 SUBTYPEP.INTEGER.29 SUBTYPEP.INTEGER.30 SUBTYPEP.INTEGER.REAL.1

 SUBTYPEP.INTEGER.REAL.2 SUBTYPEP.INTEGER.REAL.3 SUBTYPEP.INTEGER.REAL.4

 SUBTYPEP.INTEGER.REAL.5 SUBTYPEP.INTEGER.REAL.6 SUBTYPEP.INTEGER.REAL.7

 SUBTYPEP.INTEGER.REAL.8 SUBTYPEP.INTEGER.REAL.9

 SUBTYPEP.INTEGER.REAL.10 SUBTYPEP.INTEGER.REAL.11

 SUBTYPEP.INTEGER.RATIONAL.1 SUBTYPEP.INTEGER.RATIONAL.2

 SUBTYPEP.INTEGER.RATIONAL.3 SUBTYPEP.INTEGER.RATIONAL.4

 SUBTYPEP.INTEGER.RATIONAL.5 SUBTYPEP.INTEGER.RATIONAL.6

 SUBTYPEP.INTEGER.RATIONAL.7 SUBTYPEP.INTEGER.RATIONAL.8

 SUBTYPEP.INTEGER.RATIONAL.9 SUBTYPEP.INTEGER.RATIONAL.10

 SUBTYPEP.FLOAT.1 SUBTYPEP.FLOAT.2 SUBTYPEP.FLOAT.3 SUBTYPEP.FLOAT.4

 SUBTYPEP.FLOAT.5 SUBTYPEP.FLOAT.6 SUBTYPEP.FLOAT.7 SUBTYPEP.FLOAT.8

 SUBTYPEP.FLOAT.9 SUBTYPEP.FLOAT.10 SUBTYPEP.FLOAT.11 SUBTYPEP.FLOAT.12

 SUBTYPEP.FLOAT.13 SUBTYPEP.FLOAT.14 SUBTYPEP.FLOAT.15 SUBTYPEP.FLOAT.16

 SUBTYPEP.FLOAT.17 SUBTYPEP.FLOAT.18 SUBTYPEP.FLOAT.19 SUBTYPEP.FLOAT.20

 SUBTYPEP.FLOAT.21 SUBTYPEP.FLOAT.22 SUBTYPEP.FLOAT.23 SUBTYPEP.FLOAT.24

 SUBTYPEP.FLOAT.25 SUBTYPEP.FLOAT.26 SUBTYPEP.FLOAT.27

 SUBTYPEP.SHORT-FLOAT.ZERO.1 SUBTYPEP.SHORT-FLOAT.ZERO.2A

 SUBTYPEP.SHORT-FLOAT.ZERO.2B SUBTYPEP.SHORT-FLOAT.ZERO.3

 SUBTYPEP.SHORT-FLOAT.ZERO.4 SUBTYPEP.SHORT-FLOAT.ZERO.5

 SUBTYPEP.SHORT-FLOAT.ZERO.6 SUBTYPEP.SHORT-FLOAT.ZERO.7

 SUBTYPEP.SHORT-FLOAT.ZERO.8 SUBTYPEP.SHORT-FLOAT.ZERO.9

 SUBTYPEP.SHORT-FLOAT.ZERO.10 SUBTYPEP.FLOAT.ZERO.3

 SUBTYPEP.FLOAT.ZERO.4 SUBTYPEP.FLOAT.ZERO.5 SUBTYPEP.FLOAT.ZERO.6

 SUBTYPEP.FLOAT.ZERO.7 SUBTYPEP.FLOAT.ZERO.8 SUBTYPEP.FLOAT.ZERO.9

 SUBTYPEP.FLOAT.ZERO.10 SUBTYPEP.SINGLE-FLOAT.ZERO.1

 SUBTYPEP.SINGLE-FLOAT.ZERO.2A SUBTYPEP.SINGLE-FLOAT.ZERO.2B

 SUBTYPEP.SINGLE-FLOAT.ZERO.3 SUBTYPEP.SINGLE-FLOAT.ZERO.4

 SUBTYPEP.SINGLE-FLOAT.ZERO.5 SUBTYPEP.SINGLE-FLOAT.ZERO.6

 SUBTYPEP.SINGLE-FLOAT.ZERO.7 SUBTYPEP.SINGLE-FLOAT.ZERO.8

 SUBTYPEP.SINGLE-FLOAT.ZERO.9 SUBTYPEP.SINGLE-FLOAT.ZERO.10

 SUBTYPEP.LONG-FLOAT.ZERO.1 SUBTYPEP.LONG-FLOAT.ZERO.2A

 SUBTYPEP.LONG-FLOAT.ZERO.2B SUBTYPEP.LONG-FLOAT.ZERO.3

 SUBTYPEP.LONG-FLOAT.ZERO.4 SUBTYPEP.LONG-FLOAT.ZERO.5

 SUBTYPEP.LONG-FLOAT.ZERO.6 SUBTYPEP.LONG-FLOAT.ZERO.7

 SUBTYPEP.LONG-FLOAT.ZERO.8 SUBTYPEP.LONG-FLOAT.ZERO.9

 SUBTYPEP.LONG-FLOAT.ZERO.10 SUBTYPEP.DOUBLE-FLOAT.ZERO.1

 SUBTYPEP.DOUBLE-FLOAT.ZERO.2A SUBTYPEP.DOUBLE-FLOAT.ZERO.2B

 SUBTYPEP.DOUBLE-FLOAT.ZERO.3 SUBTYPEP.DOUBLE-FLOAT.ZERO.4

 SUBTYPEP.DOUBLE-FLOAT.ZERO.5 SUBTYPEP.DOUBLE-FLOAT.ZERO.6

 SUBTYPEP.DOUBLE-FLOAT.ZERO.7 SUBTYPEP.DOUBLE-FLOAT.ZERO.8

 SUBTYPEP.DOUBLE-FLOAT.ZERO.9 SUBTYPEP.DOUBLE-FLOAT.ZERO.10

 SUBTYPEP.RATIONAL.1 SUBTYPEP.RATIONAL.2 SUBTYPEP.RATIONAL.3

 SUBTYPEP.RATIONAL.4 SUBTYPEP.RATIONAL.5 SUBTYPEP.RATIONAL.6

 SUBTYPEP.RATIONAL.7 SUBTYPEP.RATIONAL.8 SUBTYPEP.RATIONAL.9

 SUBTYPEP.RATIONAL.10 SUBTYPEP.RATIONAL.11 SUBTYPEP.RATIONAL.12

 SUBTYPEP.RATIONAL.13 SUBTYPEP.RATIONAL.14 SUBTYPEP.RATIONAL.15

 SUBTYPEP.RATIONAL.16 SUBTYPEP.RATIONAL.17 SUBTYPEP.RATIONAL.18

 SUBTYPEP.REAL.1 SUBTYPEP.REAL.2 SUBTYPEP.REAL.3 SUBTYPEP.REAL.4

 SUBTYPEP.REAL.5 SUBTYPEP.REAL.6 SUBTYPEP.REAL.7 SUBTYPEP.REAL.8

 SUBTYPEP.REAL.9 SUBTYPEP.REAL.10 SUBTYPEP.REAL.11 SUBTYPEP.REAL.12

 SUBTYPEP.REAL.13 SUBTYPEP.REAL.14 SUBTYPEP.REAL.15 SUBTYPEP.REAL.16

 SUBTYPEP.REAL.17 SUBTYPEP.REAL.18 SUBTYPEP.REAL.19 SUBTYPEP.REAL.20

 SUBTYPEP.REAL.21 SUBTYPEP.REAL.22 SUBTYPEP.REAL.23 SUBTYPEP.REAL.24

 SUBTYPEP.REAL.25 SUBTYPEP.CONS.1 SUBTYPEP.CONS.2 SUBTYPEP.CONS.3

 SUBTYPEP.CONS.4 SUBTYPEP.CONS.5 SUBTYPEP.CONS.6 SUBTYPEP.CONS.7

 SUBTYPEP.CONS.8 SUBTYPEP.CONS.9 SUBTYPEP.CONS.10 SUBTYPEP.CONS.11

 SUBTYPEP.CONS.12 SUBTYPEP.CONS.13 SUBTYPEP.CONS.14 SUBTYPEP.CONS.15

 SUBTYPEP.CONS.16 SUBTYPEP.CONS.17 SUBTYPEP.CONS.18 SUBTYPEP.CONS.19

 SUBTYPEP.CONS.20 SUBTYPEP.CONS.21 SUBTYPEP.CONS.22 SUBTYPE.CONS.23

 SUBTYPE.CONS.24 SUBTYPE.CONS.25 SUBTYPE.CONS.26 SUBTYPE.CONS.27

 SUBTYPE.CONS.28 SUBTYPEP.CONS.29 SUBTYPEP.CONS.30 SUBTYPEP.CONS.31

 SUBTYPEP.CONS.32 SUBTYPEP.CONS.33 SUBTYPEP.CONS.34 SUBTYPEP.CONS.35

 SUBTYPEP.CONS.36 SUBTYPEP.CONS.37 SUBTYPEP.CONS.38 SUBTYPEP.CONS.39

 SUBTYPEP.CONS.40 SUBTYPEP.CONS.41 SUBTYPEP.CONS.42 SUBTYPEP.CONS.43

 SUBTYPEP.MEMBER.1 SUBTYPEP.MEMBER.2 SUBTYPEP.MEMBER.3 SUBTYPEP.MEMBER.4

 SUBTYPEP.MEMBER.5 SUBTYPEP.MEMBER.6 SUBTYPEP.MEMBER.7 SUBTYPEP.MEMBER.8

 SUBTYPEP.MEMBER.9 SUBTYPEP.MEMBER.10 SUBTYPEP.MEMBER.11

 SUBTYPEP.MEMBER.12 SUBTYPEP.MEMBER.13 SUBTYPEP.MEMBER.14

 SUBTYPEP.MEMBER.15 SUBTYPEP.MEMBER.16 SUBTYPEP.MEMBER.17

 SUBTYPEP.MEMBER.18 SUBTYPEP.MEMBER.19 SUBTYPEP.MEMBER.20

 SUBTYPEP.MEMBER.21 SUBTYPEP.MEMBER.22 SUBTYPEP.MEMBER.23

 SUBTYPEP.MEMBER.24 SUBTYPEP.MEMBER.25 SUBTYPEP.MEMBER.26

 SUBTYPEP.MEMBER.27 SUBTYPEP.MEMBER.28 SUBTYPEP.MEMBER.29

 SUBTYPEP.MEMBER.30 SUBTYPEP.MEMBER.31 SUBTYPEP.MEMBER.32

 SUBTYPEP.MEMBER.33 SUBTYPEP.MEMBER.34 SUBTYPEP.MEMBER.35

 SUBTYPEP.MEMBER.36 SUBTYPEP.MEMBER.37 SUBTYPEP.MEMBER.38

 SUBTYPEP.MEMBER.39 SUBTYPEP.MEMBER.40 SUBTYPEP.MEMBER.41

 SUBTYPEP.MEMBER.42 SUBTYPEP.MEMBER.43 SUBTYPEP.MEMBER.44 SUBTYPEP.EQL.1

 SUBTYPEP.EQL.2 SUBTYPEP.EQL.3 SUBTYPEP.EQL.4 SUBTYPEP.EQL.5

 SUBTYPEP.EQL.6 SUBTYPEP.EQL.7 SUBTYPEP.EQL.8 SUBTYPEP.ARRAY.1

 SUBTYPEP.ARRAY.2 SUBTYPEP.ARRAY.3 SUBTYPEP.ARRAY.4 SUBTYPEP.ARRAY.5

 SUBTYPEP.ARRAY.6 SUBTYPEP.ARRAY.7 SUBTYPEP.ARRAY.8 SUBTYPEP.ARRAY.9

 SUBTYPEP.ARRAY.10 SUBTYPEP.ARRAY.11 SUBTYPEP.ARRAY.12 SUBTYPEP.ARRAY.13

 VECTOR-OF-CHARACTER-IS-STRING.2 VECTOR-OF-CHARACTER-IS-STRING.4

 VECTOR-OF-CHARACTER-IS-STRING.6 BASE-STRING-IS-VECTOR-OF-BASE-CHAR.1

 BASE-STRING-IS-VECTOR-OF-BASE-CHAR.2

 BASE-STRING-IS-VECTOR-OF-BASE-CHAR.3

 BASE-STRING-IS-VECTOR-OF-BASE-CHAR.4

 BASE-STRING-IS-VECTOR-OF-BASE-CHAR.5

 BASE-STRING-IS-VECTOR-OF-BASE-CHAR.6

 SIMPLE-BASE-STRING-IS-SIMPLE-1D-ARRAY-OF-BASE-CHAR.1

 SIMPLE-BASE-STRING-IS-SIMPLE-1D-ARRAY-OF-BASE-CHAR.2

 SIMPLE-BASE-STRING-IS-SIMPLE-1D-ARRAY-OF-BASE-CHAR.3

 SIMPLE-BASE-STRING-IS-SIMPLE-1D-ARRAY-OF-BASE-CHAR.4

 SIMPLE-BASE-STRING-IS-SIMPLE-1D-ARRAY-OF-BASE-CHAR.5

 SIMPLE-BASE-STRING-IS-SIMPLE-1D-ARRAY-OF-BASE-CHAR.6

 SIMPLE-1D-ARRAY-OF-CHARACTER-IS-SIMPLE-STRING.2

 SIMPLE-1D-ARRAY-OF-CHARACTER-IS-SIMPLE-STRING.4

 SIMPLE-1D-ARRAY-OF-CHARACTER-IS-SIMPLE-STRING.6 VECTOR-IS-1D-ARRAY.1

 VECTOR-IS-1D-ARRAY.2 VECTOR-IS-1D-ARRAY.3 VECTOR-IS-1D-ARRAY.4

 VECTOR-IS-1D-ARRAY.5 VECTOR-IS-1D-ARRAY.6

 SIMPLE-VECTOR-IS-SIMPLE-1D-ARRAY.1 SIMPLE-VECTOR-IS-SIMPLE-1D-ARRAY.2

 SIMPLE-VECTOR-IS-SIMPLE-1D-ARRAY.3 SIMPLE-VECTOR-IS-SIMPLE-1D-ARRAY.4

 SIMPLE-VECTOR-IS-SIMPLE-1D-ARRAY.5 SIMPLE-VECTOR-IS-SIMPLE-1D-ARRAY.6

 SUBTYPEP-FUNCTION.1 SUBTYPEP-FUNCTION.2 SUBTYPEP-FUNCTION.3

 SUBTYPEP-FUNCTION.4 SUBTYPEP-COMPLEX.1 SUBTYPEP-COMPLEX.2

 SUBTYPEP-COMPLEX.3 SUBTYPEP-COMPLEX.4 SUBTYPEP-COMPLEX.5

 SUBTYPEP-COMPLEX.7 SUBTYPEP-COMPLEX.8 DEFTYPE.1 DEFTYPE.2 DEFTYPE.3

 DEFTYPE.4 DEFTYPE.5 DEFTYPE.6 DEFTYPE.7 DEFTYPE.8 DEFTYPE.9 DEFTYPE.10

 DEFTYPE.11 DEFTYPE.12 DEFTYPE.13 DEFTYPE.15 DEFTYPE.16 DEFTYPE.17

 DEFTYPE.18 DEFTYPE.19 DEFTYPE.ERROR.1 DEFTYPE.ERROR.2 DEFTYPE.ERROR.3

 STANDARD-GENERIC-FUNCTION.1 STANDARD-GENERIC-FUNCTION.2 TYPE-OF.1

 TYPE-OF.1-RELAXED TYPE-OF.2 TYPE-OF.3 TYPE-OF.4 TYPE-OF.5 TYPE-OF.6

 TYPE-OF.7 TYPE-OF.8 TYPE-OF.9 TYPE-OF.10 TYPE-OF.11 TYPE-OF.ERROR.1

 TYPE-OF.ERROR.2 TYPEP.ERROR.1 TYPEP.ERROR.2 TYPEP.ERROR.3 TYPEP.ERROR.4

 TYPEP.ERROR.5 TYPEP.ERROR.6 TYPEP.ERROR.7 TYPEP-NIL-NULL TYPEP-T-NULL

 TYPEP.ENV.1 TYPEP.ENV.2 TYPEP.ENV.3 TYPEP.1 TYPEP.2 TYPEP.3 TYPEP.4

 TYPEP.5 TYPEP.6 TYPEP.7 TYPEP.8 TYPEP.9 TYPEP.10 TYPEP.11 TYPEP.12

 TYPEP.13 TYPEP.14 TYPEP.15 TYPEP.16 TYPEP.17 TYPEP.18 TYPEP.19

 ARITHMETIC-ERROR-CPL CELL-ERROR-CPL CONDITION-CPL CONTROL-ERROR-CPL

 DIVISION-BY-ZERO-CPL END-OF-FILE-CPL ERROR-CPL FILE-ERROR-CPL

 FLOATING-POINT-INEXACT-CPL FLOATING-POINT-INVALID-OPERATION-CPL

 FLOATING-POINT-OVERFLOW-CPL FLOATING-POINT-UNDERFLOW-CPL

 PACKAGE-ERROR-CPL PARSE-ERROR-CPL PRINT-NOT-READABLE-CPL

 PROGRAM-ERROR-CPL READER-ERROR-CPL SERIOUS-CONDITION-CPL

 SIMPLE-CONDITION-CPL SIMPLE-ERROR-CPL SIMPLE-TYPE-ERROR-CPL

 SIMPLE-WARNING-CPL STORAGE-CONDITION-CPL STREAM-ERROR-CPL

 STYLE-WARNING-CPL TYPE-ERROR-CPL UNBOUND-SLOT-CPL UNBOUND-VARIABLE-CPL

 UNDEFINED-FUNCTION-CPL WARNING-CPL ARRAY-CPL BIT-VECTOR-CPL

 BROADCAST-STREAM-CPL BUILT-IN-CLASS-CPL CHARACTER-CPL.1 COMPLEX-CPL.1

 COMPLEX-CPL.2 COMPLEX-CPL.3 CONCATENATED-STREAM-CPL CONS-CPL

 ECHO-STREAM-CPL FILE-STREAM-CPL FLOAT-CPL.1 FLOAT-CPL.2 FLOAT-CPL.3

 FLOAT-CPL.4 FUNCTION-CPL HASH-TABLE-CPL.1 HASH-TABLE-CPL.2

 HASH-TABLE-CPL.3 INTEGER-CPL.1 INTEGER-CPL.2 INTEGER-CPL.3 LIST-CPL.1

 LIST-CPL.2 NULL-CPL PACKAGE-CPL PATHNAME-CPL RANDOM-STATE-CPL RATIO-CPL

 READTABLE-CPL STANDARD-CLASS-CPL STANDARD-GENERIC-FUNCTION-CPL

 STANDARD-METHOD-CPL STRING-CPL.1

Note: "abcd" not a direct instance of STRING

 STRING-CPL.2 STRING-STREAM-CPL SYMBOL-CPL SYNONYM-STREAM-CPL

 TWO-WAY-STREAM-CPL VECTOR-CPL CHAR.1 CHAR.2 CHAR.3 CHAR.4 CHAR.5 CHAR.6

 CHAR.7 CHAR.8 CHAR.9 CHAR.10 CHAR.ORDER.1 CHAR.ORDER.2 CHAR.ERROR.1

 CHAR.ERROR.2 CHAR.ERROR.3 SCHAR.1 SCHAR.2 SCHAR.3 SCHAR.4 SCHAR.5

 SCHAR.6 SCHAR.7 SCHAR.ORDER.1 SCHAR.ORDER.2 SCHAR.ERROR.1 SCHAR.ERROR.2

 SCHAR.ERROR.3 STRING.1 STRING.2 STRING.3 STRING.4 STRING.5 STRING.6

 STRING.7 STRING.11 STRING.14 STRING.15 STRING.16 STRING.17 STRING.18

 STRING.19 STRING.20 STRING.21 STRING.22 STRING.23 STRING.24 STRING.25

 STRING.26 STRING.FOLD.1 STRING.ERROR.1 STRING.ERROR.2 BASE-STRING.1

 BASE-STRING.2 BASE-STRING.3 BASE-STRING.4 SIMPLE-STRING.1

 SIMPLE-STRING.2 SIMPLE-STRING.3 SIMPLE-STRING.4 SIMPLE-STRING.5

 SIMPLE-STRING.6 SIMPLE-STRING.7 SIMPLE-STRING.14 SIMPLE-STRING.15

 SIMPLE-STRING.16 SIMPLE-STRING.17 SIMPLE-STRING.18 SIMPLE-BASE-STRING.1

 SIMPLE-BASE-STRING.2 SIMPLE-BASE-STRING.3 SIMPLE-BASE-STRING.4

 SIMPLE-BASE-STRING.5 SIMPLE-BASE-STRING.6 SIMPLE-BASE-STRING.7

 SIMPLE-BASE-STRING.8 SIMPLE-STRING-P.1 SIMPLE-STRING-P.2

 SIMPLE-STRING-P.3 SIMPLE-STRING-P.5 SIMPLE-STRING-P.6

 SIMPLE-STRING-P.10 SIMPLE-STRING-P.ERROR.1 SIMPLE-STRING-P.ERROR.2

 STRINGP.1 STRINGP.2 STRINGP.3 STRINGP.4 STRINGP.5 STRINGP.6 STRINGP.7

 STRINGP.8 STRINGP.11 STRINGP.12 STRINGP.13 STRINGP.14 STRINGP.15

 STRINGP.ERROR.1 STRINGP.ERROR.2 STRING-UPCASE.1 STRING-UPCASE.2

 STRING-UPCASE.3 STRING-UPCASE.4 STRING-UPCASE.5 STRING-UPCASE.6

 STRING-UPCASE.7 STRING-UPCASE.8 STRING-UPCASE.9 STRING-UPCASE.10

 STRING-UPCASE.12 STRING-UPCASE.13 STRING-UPCASE.14

 STRING-UPCASE.ORDER.1 STRING-UPCASE.ORDER.2 STRING-UPCASE.FOLD.1

 STRING-UPCASE.ERROR.1 STRING-UPCASE.ERROR.2 STRING-UPCASE.ERROR.3

 STRING-UPCASE.ERROR.4 STRING-UPCASE.ERROR.5 STRING-UPCASE.ERROR.6

 STRING-DOWNCASE.1 STRING-DOWNCASE.2 STRING-DOWNCASE.3 STRING-DOWNCASE.4

 STRING-DOWNCASE.5 STRING-DOWNCASE.6 STRING-DOWNCASE.7 STRING-DOWNCASE.8

 STRING-DOWNCASE.9 STRING-DOWNCASE.10 STRING-DOWNCASE.12

 STRING-DOWNCASE.13 STRING-DOWNCASE.14 STRING-DOWNCASE.ORDER.1

 STRING-DOWNCASE.ORDER.2 STRING-DOWNCASE.FOLD.1 STRING-DOWNCASE.ERROR.1

 STRING-DOWNCASE.ERROR.2 STRING-DOWNCASE.ERROR.3 STRING-DOWNCASE.ERROR.4

 STRING-DOWNCASE.ERROR.5 STRING-DOWNCASE.ERROR.6 STRING-CAPITALIZE.1

 STRING-CAPITALIZE.2 STRING-CAPITALIZE.3 STRING-CAPITALIZE.4

 STRING-CAPITALIZE.5 STRING-CAPITALIZE.6 STRING-CAPITALIZE.7

 STRING-CAPITALIZE.8 STRING-CAPITALIZE.9 STRING-CAPITALIZE.10

 STRING-CAPITALIZE.12 STRING-CAPITALIZE.13 STRING-CAPITALIZE.14

 STRING-CAPITALIZE.ORDER.1 STRING-CAPITALIZE.ORDER.2

 STRING-CAPITALIZE.FOLD.1 STRING-CAPITALIZE.ERROR.1

 STRING-CAPITALIZE.ERROR.2 STRING-CAPITALIZE.ERROR.3

 STRING-CAPITALIZE.ERROR.4 STRING-CAPITALIZE.ERROR.5

 STRING-CAPITALIZE.ERROR.6 NSTRING-UPCASE.1 NSTRING-UPCASE.2

 NSTRING-UPCASE.3 NSTRING-UPCASE.6 NSTRING-UPCASE.7 NSTRING-UPCASE.8

 NSTRING-UPCASE.9 NSTRING-UPCASE.10 NSTRING-UPCASE.12 NSTRING-UPCASE.13

 NSTRING-UPCASE.14 NSTRING-UPCASE.ORDER.1 NSTRING-UPCASE.ORDER.2

 NSTRING-UPCASE.ERROR.1 NSTRING-UPCASE.ERROR.2 NSTRING-UPCASE.ERROR.3

 NSTRING-UPCASE.ERROR.4 NSTRING-UPCASE.ERROR.5 NSTRING-UPCASE.ERROR.6

 NSTRING-DOWNCASE.1 NSTRING-DOWNCASE.2 NSTRING-DOWNCASE.3

 NSTRING-DOWNCASE.6 NSTRING-DOWNCASE.7 NSTRING-DOWNCASE.8

 NSTRING-DOWNCASE.9 NSTRING-DOWNCASE.10 NSTRING-DOWNCASE.12

 NSTRING-DOWNCASE.13 NSTRING-DOWNCASE.14 NSTRING-DOWNCASE.ORDER.1

 NSTRING-DOWNCASE.ORDER.2 NSTRING-DOWNCASE.ERROR.1

 NSTRING-DOWNCASE.ERROR.2 NSTRING-DOWNCASE.ERROR.3

 NSTRING-DOWNCASE.ERROR.4 NSTRING-DOWNCASE.ERROR.5

 NSTRING-DOWNCASE.ERROR.6 NSTRING-CAPITALIZE.1 NSTRING-CAPITALIZE.2

 NSTRING-CAPITALIZE.3 NSTRING-CAPITALIZE.4 NSTRING-CAPITALIZE.7

 NSTRING-CAPITALIZE.8 NSTRING-CAPITALIZE.9 NSTRING-CAPITALIZE.10

 NSTRING-CAPITALIZE.11 NSTRING-CAPITALIZE.13 NSTRING-CAPITALIZE.14

 NSTRING-CAPITALIZE.15 NSTRING-CAPITALIZE.ORDER.1

 NSTRING-CAPITALIZE.ORDER.2 NSTRING-CAPITALIZE.ERROR.1

 NSTRING-CAPITALIZE.ERROR.2 NSTRING-CAPITALIZE.ERROR.3

 NSTRING-CAPITALIZE.ERROR.4 NSTRING-CAPITALIZE.ERROR.5

 NSTRING-CAPITALIZE.ERROR.6 STRING-TRIM.1 STRING-TRIM.2 STRING-TRIM.3

 STRING-TRIM.4 STRING-TRIM.5 STRING-TRIM.6 STRING-TRIM.7 STRING-TRIM.8

 STRING-TRIM.8A STRING-TRIM.9 STRING-TRIM.10 STRING-TRIM.10A

 STRING-TRIM.11 STRING-TRIM.12 STRING-TRIM.13 STRING-TRIM.14

 STRING-TRIM.15 STRING-TRIM.16 STRING-TRIM.17 STRING-TRIM.18

 STRING-TRIM.19 STRING-TRIM.22 STRING-TRIM.23 STRING-TRIM.24

 STRING-TRIM.25 STRING-TRIM.ORDER.1 STRING-TRIM.FOLD.1

 STRING-TRIM.ERROR.1 STRING-TRIM.ERROR.2 STRING-TRIM.ERROR.3

 STRING-LEFT-TRIM.1 STRING-LEFT-TRIM.2 STRING-LEFT-TRIM.3

 STRING-LEFT-TRIM.4 STRING-LEFT-TRIM.5 STRING-LEFT-TRIM.6

 STRING-LEFT-TRIM.7 STRING-LEFT-TRIM.8 STRING-LEFT-TRIM.9

 STRING-LEFT-TRIM.10 STRING-LEFT-TRIM.10A STRING-LEFT-TRIM.10B

 STRING-LEFT-TRIM.11 STRING-LEFT-TRIM.12 STRING-LEFT-TRIM.13

 STRING-LEFT-TRIM.14 STRING-LEFT-TRIM.15 STRING-LEFT-TRIM.16

 STRING-LEFT-TRIM.17 STRING-LEFT-TRIM.18 STRING-LEFT-TRIM.19

 STRING-LEFT-TRIM.22 STRING-LEFT-TRIM.23 STRING-LEFT-TRIM.24

 STRING-LEFT-TRIM.25 STRING-LEFT-TRIM.ORDER.1 STRING-LEFT-TRIM.FOLD.1

 STRING-LEFT-TRIM.ERROR.1 STRING-LEFT-TRIM.ERROR.2

 STRING-LEFT-TRIM.ERROR.3 STRING-RIGHT-TRIM.1 STRING-RIGHT-TRIM.2

 STRING-RIGHT-TRIM.3 STRING-RIGHT-TRIM.4 STRING-RIGHT-TRIM.5

 STRING-RIGHT-TRIM.6 STRING-RIGHT-TRIM.7 STRING-RIGHT-TRIM.8

 STRING-RIGHT-TRIM.9 STRING-RIGHT-TRIM.10 STRING-RIGHT-TRIM.10A

 STRING-RIGHT-TRIM.10B STRING-RIGHT-TRIM.11 STRING-RIGHT-TRIM.12

 STRING-RIGHT-TRIM.13 STRING-RIGHT-TRIM.14 STRING-RIGHT-TRIM.15

 STRING-RIGHT-TRIM.16 STRING-RIGHT-TRIM.17 STRING-RIGHT-TRIM.18

 STRING-RIGHT-TRIM.19 STRING-RIGHT-TRIM.22 STRING-RIGHT-TRIM.23

 STRING-RIGHT-TRIM.24 STRING-RIGHT-TRIM.25 STRING-RIGHT-TRIM.ORDER.1

 STRING-RIGHT-TRIM.FOLD.1 STRING-RIGHT-TRIM.ERROR.1

 STRING-RIGHT-TRIM.ERROR.2 STRING-RIGHT-TRIM.ERROR.3 STRING=.1 STRING=.2

 STRING=.3 STRING=.4 STRING=.5 STRING=.6 STRING=.7 STRING=.8 STRING=.9

 STRING=.10 STRING=.11 STRING=.12 STRING=.13 STRING=.14

 STRING-COMPARISON.ALLOW-OTHER-KEYS.1

 STRING-COMPARISON.ALLOW-OTHER-KEYS.2

 STRING-COMPARISON.ALLOW-OTHER-KEYS.3 STRING=.ORDER.1 STRING=.ORDER.2

 STRING=.ORDER.3 STRING<=.ORDER.1 STRING<=.ORDER.2 STRING<=.ORDER.3

 STRING<.ORDER.1 STRING<.ORDER.2 STRING<.ORDER.3 STRING/=.ORDER.1

 STRING/=.ORDER.2 STRING/=.ORDER.3 STRING>=.ORDER.1 STRING>=.ORDER.2

 STRING>=.ORDER.3 STRING>.ORDER.1 STRING>.ORDER.2 STRING>.ORDER.3

 STRING-EQUAL.ORDER.1 STRING-EQUAL.ORDER.2 STRING-EQUAL.ORDER.3

 STRING-NOT-GREATERP.ORDER.1 STRING-NOT-GREATERP.ORDER.2

 STRING-NOT-GREATERP.ORDER.3 STRING-LESSP.ORDER.1 STRING-LESSP.ORDER.2

 STRING-LESSP.ORDER.3 STRING-NOT-EQUAL.ORDER.1 STRING-NOT-EQUAL.ORDER.2

 STRING-NOT-EQUAL.ORDER.3 STRING-NOT-LESSP.ORDER.1

 STRING-NOT-LESSP.ORDER.2 STRING-NOT-LESSP.ORDER.3

 STRING-GREATERP.ORDER.1 STRING-GREATERP.ORDER.2 STRING-GREATERP.ORDER.3

 RANDOM-STRING-COMPARISON-TESTS STRING=.ERROR.1 STRING=.ERROR.2

 STRING=.ERROR.3 STRING=.ERROR.4 STRING=.ERROR.5 STRING=.ERROR.6

 STRING/=.ERROR.1 STRING/=.ERROR.2 STRING/=.ERROR.3 STRING/=.ERROR.4

 STRING/=.ERROR.5 STRING/=.ERROR.6 STRING<.ERROR.1 STRING<.ERROR.2

 STRING<.ERROR.3 STRING<.ERROR.4 STRING<.ERROR.5 STRING<.ERROR.6

 STRING<=.ERROR.1 STRING<=.ERROR.2 STRING<=.ERROR.3 STRING<=.ERROR.4

 STRING<=.ERROR.5 STRING<=.ERROR.6 STRING>.ERROR.1 STRING>.ERROR.2

 STRING>.ERROR.3 STRING>.ERROR.4 STRING>.ERROR.5 STRING>.ERROR.6

 STRING>=.ERROR.1 STRING>=.ERROR.2 STRING>=.ERROR.3 STRING>=.ERROR.4

 STRING>=.ERROR.5 STRING>=.ERROR.6 STRING-EQUAL.ERROR.1

 STRING-EQUAL.ERROR.2 STRING-EQUAL.ERROR.3 STRING-EQUAL.ERROR.4

 STRING-EQUAL.ERROR.5 STRING-EQUAL.ERROR.6 STRING-NOT-EQUAL.ERROR.1

 STRING-NOT-EQUAL.ERROR.2 STRING-NOT-EQUAL.ERROR.3

 STRING-NOT-EQUAL.ERROR.4 STRING-NOT-EQUAL.ERROR.5

 STRING-NOT-EQUAL.ERROR.6 STRING-LESSP.ERROR.1 STRING-LESSP.ERROR.2

 STRING-LESSP.ERROR.3 STRING-LESSP.ERROR.4 STRING-LESSP.ERROR.5

 STRING-LESSP.ERROR.6 STRING-GREATERP.ERROR.1 STRING-GREATERP.ERROR.2

 STRING-GREATERP.ERROR.3 STRING-GREATERP.ERROR.4 STRING-GREATERP.ERROR.5

 STRING-GREATERP.ERROR.6 STRING-NOT-LESSP.ERROR.1

 STRING-NOT-LESSP.ERROR.2 STRING-NOT-LESSP.ERROR.3

 STRING-NOT-LESSP.ERROR.4 STRING-NOT-LESSP.ERROR.5

 STRING-NOT-LESSP.ERROR.6 STRING-NOT-GREATERP.ERROR.1

 STRING-NOT-GREATERP.ERROR.2 STRING-NOT-GREATERP.ERROR.3

 STRING-NOT-GREATERP.ERROR.4 STRING-NOT-GREATERP.ERROR.5

 STRING-NOT-GREATERP.ERROR.6 MAKE-STRING.1 MAKE-STRING.2 MAKE-STRING.3

 MAKE-STRING.4 MAKE-STRING.5 MAKE-STRING.6 MAKE-STRING.7 MAKE-STRING.8

 MAKE-STRING.9 MAKE-STRING.FOLD.1 MAKE-STRING.ALLOW-OTHER-KEYS.1

 MAKE-STRING.ALLOW-OTHER-KEYS.2 MAKE-STRING.ALLOW-OTHER-KEYS.3

 MAKE-STRING.ALLOW-OTHER-KEYS.4 MAKE-STRING.ALLOW-OTHER-KEYS.5

 MAKE-STRING.ALLOW-OTHER-KEYS.6 MAKE-STRING.KEYWORDS.7

 MAKE-STRING.ERROR.1 MAKE-STRING.ERROR.2 MAKE-STRING.ERROR.3

 MAKE-STRING.ERROR.4 MAKE-STRING.ERROR.5 MAKE-STRING.ERROR.6

 MAKE-STRING.ORDER.1 MAKE-STRING.ORDER.2 MAKE-STRING.ORDER.3

 CHARACTER-CLASS.1 BASE-CHAR.1 BASE-CHAR.2 BASE-CHAR.3 STANDARD-CHAR.1

 STANDARD-CHAR.2 STANDARD-CHAR.3 STANDARD-CHAR.4 STANDARD-CHAR.5

 EXTENDED-CHAR.1 EXTENDED-CHAR.2 EXTENDED-CHAR.3 CHARACTER.1 CHARACTER.2

 CHARACTER.ORDER.1 CHARACTER.ERROR.1 CHARACTER.ERROR.2 CHARACTERP.1

 CHARACTERP.2 CHARACTERP.3 CHARACTERP.ORDER.1 CHARACTERP.ERROR.1

 CHARACTERP.ERROR.2 ALPHA-CHAR-P.1 ALPHA-CHAR-P.2 ALPHA-CHAR-P.3

 ALPHA-CHAR-P.4 ALPHA-CHAR-P.ORDER.1 ALPHA-CHAR-P.ERROR.1

 ALPHA-CHAR-P.ERROR.2 ALPHANUMERICP.1 ALPHANUMERICP.2 ALPHANUMERICP.3

 ALPHANUMERICP.4 ALPHANUMERICP.5 ALPHANUMBERICP.6 ALPHANUMERICP.ORDER.1

 ALPHANUMERICP.ERROR.1 ALPHANUMERICP.ERROR.2 DIGIT-CHAR.1 DIGIT-CHAR.2

 DIGIT-CHAR.ORDER.1 DIGIT-CHAR.ORDER.2 DIGIT-CHAR.ERROR.1

 DIGIT-CHAR.ERROR.2 DIGIT-CHAR-P.1 DIGIT-CHAR-P.2 DIGIT-CHAR-P.3

 DIGIT-CHAR-P.4 DIGIT-CHAR-P.5 DIGIT-CHAR-P.6 DIGIT-CHAR-P.ORDER.1

 DIGIT-CHAR-P.ORDER.2 DIGIT-CHAR-P.ERROR.1 DIGIT-CHAR-P.ERROR.2

 GRAPHIC-CHAR-P.1 GRAPHIC-CHAR-P.2 GRAPHIC-CHAR-P.3

 GRAPHIC-CHAR-P.ORDER.1 GRAPHIC-CHAR-P.ERROR.1 GRAPHIC-CHAR-P.ERROR.2

 STANDARD-CHAR-P.1 STANDARD-CHAR-P.2 STANDARD-CHAR-P.2A

 STANDARD-CHAR-P.3 STANDARD-CHAR-P.ORDER.1 STANDARD-CHAR-P.ERROR.1

 STANDARD-CHAR-P.ERROR.2 CHAR-UPCASE.1 CHAR-UPCASE.2 CHAR-UPCASE.3

 CHAR-UPCASE.4 CHAR-UPCASE.ORDER.1 CHAR-UPCASE.ERROR.1

 CHAR-UPCASE.ERROR.2 CHAR-DOWNCASE.1 CHAR-DOWNCASE.2 CHAR-DOWNCASE.3

 CHAR-DOWNCASE.4 CHAR-DOWNCASE.ORDER.1 CHAR-DOWNCASE.ERROR.1

 CHAR-DOWNCASE.ERROR.2 UPPER-CASE-P.1 UPPER-CASE-P.2 UPPER-CASE-P.3

 UPPER-CASE-P.4 UPPER-CASE-P.ORDER.1 UPPER-CASE-P.ERROR.1

 UPPER-CASE-P.ERROR.2 LOWER-CASE-P.1 LOWER-CASE-P.2 LOWER-CASE-P.3

 LOWER-CASE-P.ORDER.1 LOWER-CASE-P.ERROR.1 LOWER-CASE-P.ERROR.2

 BOTH-CASE-P.1 BOTH-CASE-P.2 BOTH-CASE-P.3 BOTH-CASE-P.4

 BOTH-CASE-P.ORDER.1 BOTH-CASE-P.ERROR.1 BOTH-CASE-P.ERROR.2 CHAR-CODE.1

 CHAR-CODE.2 CHAR-CODE.ORDER.1 CHAR-CODE.ERROR.1 CHAR-CODE.ERROR.2

 CODE-CHAR.1 CODE-CHAR.ORDER.1 CODE-CHAR.ERROR.1 CODE-CHAR.ERROR.2

 CHAR-INT.1 CHAR-INT.2 CHAR-INT.ORDER.1 CHAR-INT.ERROR.1

 CHAR-INT.ERROR.2 CHAR-NAME.1 CHAR-NAME.2 CHAR-NAME.3 CHAR-NAME.4

 CHAR-NAME.5 CHAR-NAME.ORDER.1 CHAR-NAME.ERROR.1 CHAR-NAME.ERROR.2

 CHAR-COMPARE-NO-ARGS CHAR=.1 CHAR=.2 CHAR=.3 CHAR=.4 CHAR=.ORDER.1

 CHAR=.ORDER.2 CHAR=.ORDER.3 CHAR/=.1 CHAR/=.2 CHAR/=.3 CHAR/=.4

 CHAR/=.ORDER.1 CHAR/=.ORDER.2 CHAR/=.ORDER.3 CHAR<=.1 CHAR<=.2 CHAR<=.3

 CHAR<=.4 CHAR<=.5 CHAR<=.6 CHAR<=.7 CHAR<=.8 CHAR<=.ORDER.1

 CHAR<=.ORDER.2 CHAR<=.ORDER.3 CHAR<.1 CHAR<.2 CHAR<.3 CHAR<.4 CHAR<.5

 CHAR<.6 CHAR<.7 CHAR<.8 CHAR<.ORDER.1 CHAR<.ORDER.2 CHAR<.ORDER.3

 CHAR<.ORDER.4 CHAR>=.1 CHAR>=.2 CHAR>=.3 CHAR>=.4 CHAR>=.5 CHAR>=.6

 CHAR>=.7 CHAR>=.8 CHAR>=.ORDER.1 CHAR>=.ORDER.2 CHAR>=.ORDER.3

 CHAR>=.ORDER.4 CHAR>.1 CHAR>.2 CHAR>.3 CHAR>.4 CHAR>.5 CHAR>.6 CHAR>.7

 CHAR>.8 CHAR>.ORDER.1 CHAR>.ORDER.2 CHAR>.ORDER.3 CHAR>.ORDER.4

 CHAR-EQUAL.1 CHAR-EQUAL.2 CHAR-EQUAL.3 CHAR-EQUAL.4 CHAR-EQUAL.ORDER.1

 CHAR-EQUAL.ORDER.2 CHAR-EQUAL.ORDER.3 CHAR-EQUAL.ORDER.4

 CHAR-NOT-EQUAL.1 CHAR-NOT-EQUAL.2 CHAR-NOT-EQUAL.3 CHAR-NOT-EQUAL.4

 CHAR-NOT-EQUAL.ORDER.1 CHAR-NOT-EQUAL.ORDER.2 CHAR-NOT-EQUAL.ORDER.3

 CHAR-NOT-EQUAL.ORDER.4 CHAR-NOT-GREATERP.1 CHAR-NOT-GREATERP.2

 CHAR-NOT-GREATERP.3 CHAR-NOT-GREATERP.4 CHAR-NOT-GREATERP.5

 CHAR-NOT-GREATERP.6 CHAR-NOT-GREATERP.7 CHAR-NOT-GREATERP.8

 CHAR-NOT-GREATERP.ORDER.1 CHAR-NOT-GREATERP.ORDER.2

 CHAR-NOT-GREATERP.ORDER.3 CHAR-NOT-GREATERP.ORDER.4 CHAR-LESSP.1

 CHAR-LESSP.2 CHAR-LESSP.3 CHAR-LESSP.4 CHAR-LESSP.5 CHAR-LESSP.6

 CHAR-LESSP.7 CHAR-LESSP.8 CHAR-LESSP.ORDER.1 CHAR-LESSP.ORDER.2

 CHAR-LESSP.ORDER.3 CHAR-LESSP.ORDER.4 CHAR-NOT-LESSP.1 CHAR-NOT-LESSP.2

 CHAR-NOT-LESSP.3 CHAR-NOT-LESSP.4 CHAR-NOT-LESSP.5 CHAR-NOT-LESSP.6

 CHAR-NOT-LESSP.7 CHAR-NOT-LESSP.8 CHAR-NOT-LESSP.ORDER.1

 CHAR-NOT-LESSP.ORDER.2 CHAR-NOT-LESSP.ORDER.3 CHAR-NOT-LESSP.ORDER.4

 CHAR-GREATERP.1 CHAR-GREATERP.2 CHAR-GREATERP.3 CHAR-GREATERP.4

 CHAR-GREATERP.5 CHAR-GREATERP.6 CHAR-GREATERP.7 CHAR-GREATERP.8

 CHAR-GREATERP.ORDER.1 CHAR-GREATERP.ORDER.2 CHAR-GREATERP.ORDER.3

 CHAR-GREATERP.ORDER.4 NAME-CHAR.1 NAME-CHAR.2 NAME-CHAR.ORDER.1

 NAME-CHAR.SPECIALIZED.1 NAME-CHAR.SPECIALIZED.2 NAME-CHAR.SPECIALIZED.3

 NAME-CHAR.SPECIALIZED.4 NAME-CHAR.ERROR.1 NAME-CHAR.ERROR.2

 PATHNAMES-PRINT-AND-READ-PROPERLY PATHNAME.1 PATHNAME.2 PATHNAME.3

 PATHNAME.4 PATHNAME.5 PATHNAME.6 PATHNAME.7 PATHNAME.8 PATHNAME.9

 PATHNAME.10 PATHNAME.11 PATHNAME.ERROR.1 PATHNAME.ERROR.2 PATHNAMEP.1

 PATHNAMEP.2 PATHNAMEP.3 PATHNAMEP.ERROR.1 PATHNAMEP.ERROR.2

 PATHNAMEP.ERROR.3 MAKE-PATHNAME.1 MAKE-PATHNAME.2 MAKE-PATHNAME.2A

 MAKE-PATHNAME.3 MAKE-PATHNAME.3A MAKE-PATHNAME.4 MAKE-PATHNAME.5

 MAKE-PATHNAME.6 MAKE-PATHNAME.7 MAKE-PATHNAME.8 MAKE-PATHNAME.9

 MAKE-PATHNAME.10 MAKE-PATHNAME.11 MAKE-PATHNAME.12 MAKE-PATHNAME.13

 MAKE-PATHNAME.14 MAKE-PATHNAME.REBUILD MAKE-PATHNAME-ERROR-ABSOLUTE-UP

 MAKE-PATHNAME-ERROR-ABSOLUTE-BACK

 MAKE-PATHNAME-ERROR-RELATIVE-WILD-INFERIORS-UP

 MAKE-PATHNAME-ERROR-ABSOLUTE-WILD-INFERIORS-BACK

 MAKE-PATHNAME-ERROR-RELATIVE-WILD-INFERIORS-BACK PATHNAME-HOST.1

 PATHNAME-HOST.2 PATHNAME-HOST.3 PATHNAME-HOST.4 PATHNAME-HOST.5

 PATHNAME-HOST.6 PATHNAME-HOST.7 PATHNAME-HOST.8 PATHNAME-HOST.ERROR.1

 PATHNAME-HOST.ERROR.2 PATHNAME-HOST.ERROR.3 PATHNAME-DEVICE.1

 PATHNAME-DEVICE.2 PATHNAME-DEVICE.3 PATHNAME-DEVICE.4 PATHNAME-DEVICE.5

 PATHNAME-DEVICE.6 PATHNAME-DEVICE.7 PATHNAME-DEVICE.8

 PATHNAME-DEVICE.ERROR.1 PATHNAME-DEVICE.ERROR.2 PATHNAME-DIRECTORY.1

 PATHNAME-DIRECTORY.2 PATHNAME-DIRECTORY.3 PATHNAME-DIRECTORY.4

 PATHNAME-DIRECTORY.5 PATHNAME-DIRECTORY.6 PATHNAME-DIRECTORY.7

 PATHNAME-DIRECTORY.8 PATHNAME-DIRECTORY.ERROR.1

 PATHNAME-DIRECTORY.ERROR.2 PATHNAME-NAME.1 PATHNAME-NAME.2

 PATHNAME-NAME.3 PATHNAME-NAME.4 PATHNAME-NAME.5 PATHNAME-NAME.6

 PATHNAME-NAME.7 PATHNAME-NAME.8 PATHNAME-NAME.ERROR.1

 PATHNAME-NAME.ERROR.2 PATHNAME-TYPE.1 PATHNAME-TYPE.2 PATHNAME-TYPE.3

 PATHNAME-TYPE.4 PATHNAME-TYPE.5 PATHNAME-TYPE.6 PATHNAME-TYPE.7

 PATHNAME-TYPE.8 PATHNAME-TYPE.ERROR.1 PATHNAME-TYPE.ERROR.2

 PATHNAME-VERSION.1 PATHNAME-VERSION.2 PATHNAME-VERSION.3

 PATHNAME-VERSION.ERROR.1 PATHNAME-VERSION.ERROR.2

 PATHNAME-VERSION.ERROR.3 LOAD-LOGICAL-PATHNAME-TRANSLATIONS.1

 LOAD-LOGICAL-PATHNAME-TRANSLATIONS.ERROR.1

 LOAD-LOGICAL-PATHNAME-TRANSLATIONS.ERROR.2

 LOAD-LOGICAL-PATHNAME-TRANSLATIONS.ERROR.3 LOGICAL-PATHNAME.1

 LOGICAL-PATHNAME.2 LOGICAL-PATHNAME.3 LOGICAL-PATHNAME.ERROR.1

 LOGICAL-PATHNAME.ERROR.2 LOGICAL-PATHNAME.ERROR.3

 LOGICAL-PATHNAME.ERROR.4 LOGICAL-PATHNAME.ERROR.5

 LOGICAL-PATHNAME.ERROR.6 LOGICAL-PATHNAME.ERROR.7

 LOGICAL-PATHNAME.ERROR.8 LOGICAL-PATHNAME.ERROR.9

 LOGICAL-PATHNAME.ERROR.10 TRANSLATE-LOGICAL-PATHNAME.1

 TRANSLATE-LOGICAL-PATHNAME.2 TRANSLATE-LOGICAL-PATHNAME.3

 TRANSLATE-LOGICAL-PATHNAME.4 TRANSLATE-LOGICAL-PATHNAME.ERROR.1

 NAMESTRING.1 NAMESTRING.2 NAMESTRING.ERROR.1 NAMESTRING.ERROR.2

 FILE-NAMESTRING.1 FILE-NAMESTRING.2 FILE-NAMESTRING.3

 FILE-NAMESTRING.ERROR.1 FILE-NAMESTRING.ERROR.2 DIRECTORY-NAMESTRING.1

 DIRECTORY-NAMESTRING.2 DIRECTORY-NAMESTRING.3

 DIRECTORY-NAMESTRING.ERROR.1 DIRECTORY-NAMESTRING.ERROR.2

 HOST-NAMESTRING.1 HOST-NAMESTRING.2 HOST-NAMESTRING.3

 HOST-NAMESTRING.ERROR.1 HOST-NAMESTRING.ERROR.2 ENOUGH-NAMESTRING.1

 ENOUGH-NAMESTRING.2 ENOUGH-NAMESTRING.3 ENOUGH-NAMESTRING.4

 ENOUGH-NAMESTRING.5 ENOUGH-NAMESTRING.6 ENOUGH-NAMESTRING.7

 ENOUGH-NAMESTRING.ERROR.1 ENOUGH-NAMESTRING.ERROR.2 WILD-PATHNAME-P.1

 WILD-PATHNAME-P.2 WILD-PATHNAME-P.3 WILD-PATHNAME-P.4 WILD-PATHNAME-P.5

 WILD-PATHNAME-P.6 WILD-PATHNAME-P.7 WILD-PATHNAME-P.8 WILD-PATHNAME-P.9

 WILD-PATHNAME-P.10 WILD-PATHNAME-P.11 WILD-PATHNAME-P.12

 WILD-PATHNAME-P.13 WILD-PATHNAME-P.14 WILD-PATHNAME-P.15

 WILD-PATHNAME-P.16 WILD-PATHNAME-P.17 WILD-PATHNAME-P.18

 WILD-PATHNAME-P.19 WILD-PATHNAME-P.20 WILD-PATHNAME-P.21

 WILD-PATHNAME-P.22 WILD-PATHNAME-P.23 WILD-PATHNAME-P.24

 WILD-PATHNAME-P.25 WILD-PATHNAME-P.26 WILD-PATHNAME-P.27

 WILD-PATHNAME-P.28 WILD-PATHNAME-P.29 WILD-PATHNAME-P.30

 WILD-PATHNAME-P.31 WILD-PATHNAME-P.32 WILD-PATHNAME-P.ERROR.1

 WILD-PATHNAME-P.ERROR.2 WILD-PATHNAME-P.ERROR.3 WILD-PATHNAME-P.ERROR.4

 MERGE-PATHNAMES.1 MERGE-PATHNAMES.2 MERGE-PATHNAMES.3 MERGE-PATHNAMES.4

 MERGE-PATHNAMES.5 MERGE-PATHNAMES.6 MERGE-PATHNAMES.7

 PATHNAME-MATCH-P.1 PATHNAME-MATCH-P.2 PATHNAME-MATCH-P.3

 PATHNAME-MATCH-P.4 PATHNAME-MATCH-P.5 PATHNAME-MATCH-P.6

 PATHNAME-MATCH-P.7 PATHNAME-MATCH-P.8 PATHNAME-MATCH-P.ERROR.1

 PATHNAME-MATCH-P.ERROR.2 PATHNAME-MATCH-P.ERROR.3

 PATHNAME-MATCH-P.ERROR.4 PATHNAME-MATCH-P.ERROR.5

 PATHNAME-MATCH-P.ERROR.6 PATHNAME-MATCH-P.ERROR.7 PARSE-NAMESTRING.1

 PARSE-NAMESTRING.2 PARSE-NAMESTRING.3 PARSE-NAMESTRING.4

 PARSE-NAMESTRING.ERROR.1 PARSE-NAME-STRING.ERROR.2

 PARSE-NAME-STRING.ERROR.3 DIRECTORY.1 DIRECTORY.2 DIRECTORY.3

 DIRECTORY.4 DIRECTORY.5 DIRECTORY.6 DIRECTORY.7 DIRECTORY.8 DIRECTORY.9

 DIRECTORY.ERROR.1 PROBE-FILE.1 PROBE-FILE.2 PROBE-FILE.3 PROBE-FILE.4

 PROBE-FILE.5 PROBE-FILE.ERROR.1 PROBE-FILE.ERROR.2 PROBE-FILE.ERROR.3

 PROBE-FILE.ERROR.4 ENSURE-DIRECTORIES-EXIST.1

 ENSURE-DIRECTORIES-EXIST.2 ENSURE-DIRECTORIES-EXIST.3

 ENSURE-DIRECTORIES-EXIST.4 ENSURE-DIRECTORIES-EXIST.5

 ENSURE-DIRECTORIES-EXIST.6 ENSURE-DIRECTORIES-EXIST.7

Test ENSURE-DIRECTORIES-EXIST.8 failed

Form: (LET* ((SUBDIR

              (MAKE-PATHNAME :DIRECTORY

                             '(:RELATIVE "scratch")

                             :DEFAULTS

                             *DEFAULT-PATHNAME-DEFAULTS*))

             (PN (MAKE-PATHNAME :NAME "foo" :TYPE "txt" :DEFAULTS SUBDIR)))

        (ASSERT (NOT (PROBE-FILE PN))

                NIL

                "Delete subdirectory scratch and its contents!")

        (LET* ((RESULTS NIL)

               (VERBOSITY

                (WITH-OUTPUT-TO-STRING (*STANDARD-OUTPUT*)

                  (SETQ RESULTS

                          (MULTIPLE-VALUE-LIST

                           (ENSURE-DIRECTORIES-EXIST PN)))))

               (RESULT-PN (FIRST RESULTS))

               (CREATED (SECOND RESULTS)))

          (WITH-OPEN-FILE

              (*STANDARD-OUTPUT* PN :DIRECTION :OUTPUT :IF-EXISTS :ERROR

               :IF-DOES-NOT-EXIST :CREATE)

            (PRINT NIL))

          (VALUES (LENGTH RESULTS)

                  (NOTNOT CREATED)

                  (EQUALT PN RESULT-PN)

                  (NOTNOT (PROBE-FILE PN))

                  VERBOSITY)))

Expected values: 2

                 T

                 T

                 T

                 ""

Actual value: #<a SIMPLE-ERROR>.

 ENSURE-DIRECTORIES-EXIST.9 ENSURE-DIRECTORIES-EXIST.ERROR.1

 ENSURE-DIRECTORIES-EXIST.ERROR.2 TRUENAME.1 TRUENAME.2 TRUENAME.3

 TRUENAME.4 TRUENAME.5 TRUENAME.6 TRUENAME.ERROR.1 TRUENAME.ERROR.2

 TRUENAME.ERROR.3 TRUENAME.ERROR.4 TRUENAME.ERROR.5 TRUENAME.ERROR.6

 FILE-AUTHOR.1 FILE-AUTHOR.2 FILE-AUTHOR.3 FILE-AUTHOR.4 FILE-AUTHOR.5

 FILE-AUTHOR.6 FILE-AUTHOR.7 FILE-AUTHOR.ERROR.1 FILE-AUTHOR.ERROR.2

 FILE-AUTHOR.ERROR.3 FILE-AUTHOR.ERROR.4 FILE-WRITE-DATE.1

 FILE-WRITE-DATE.2 FILE-WRITE-DATE.3 FILE-WRITE-DATE.4 FILE-WRITE-DATE.5

 FILE-WRITE-DATE.6 FILE-WRITE-DATE.ERROR.1 FILE-WRITE-DATE.ERROR.2

 FILE-WRITE-DATE.ERROR.3 FILE-WRITE-DATE.ERROR.4 RENAME-FILE.1

 RENAME-FILE.2 RENAME-FILE.3 RENAME-FILE.4 RENAME-FILE.5 RENAME-FILE.6

 RENAME-FILE.7 RENAME-FILE.ERROR.1 DELETE-FILE.1 DELETE-FILE.2

 DELETE-FILE.3 DELETE-FILE.4 DELETE-FILE.5 DELETE-FILE.ERROR.1

 DELETE-FILE.ERROR.2 FILE-ERROR.1 FILE-ERROR-PATHNAME.1

 FILE-ERROR-PATHNAME.2 FILE-ERROR-PATHNAME.3 FILE-ERROR-PATHNAME.4

 FILE-ERROR-PATHNAME.5 FILE-ERROR-PATHNAME.6 FILE-ERROR-PATHNAME.ERROR.1

 FILE-ERROR-PATHNAME.ERROR.2 INPUT-STREAM-P.1 INPUT-STREAM-P.2

 INPUT-STREAM-P.3 INPUT-STREAM-P.4 INPUT-STREAM-P.ERROR.1

 INPUT-STREAM-P.ERROR.2 INPUT-STREAM-P.ERROR.3 OUTPUT-STREAM-P.1

 OUTPUT-STREAM-P.2 OUTPUT-STREAM-P.3 OUTPUT-STREAM-P.4

 OUTPUT-STREAM-P.ERROR.1 OUTPUT-STREAM-P.ERROR.2 OUTPUT-STREAM-P.ERROR.3

 INTERACTIVE-STREAM-P.1 INTERACTIVE-STREAM-P.ERROR.1

 INTERACTIVE-STREAM-P.ERROR.2 INTERACTIVE-STREAM-P.ERROR.3

 OPEN-STREAM-P.1 OPEN-STREAM-P.2 OPEN-STREAM-P.3 OPEN-STREAM-P.4

 OPEN-STREAM-P.5 OPEN-STREAM-P.ERROR.1 OPEN-STREAM-P.ERROR.2

 OPEN-STREAM-P.ERROR.3 STREAM-ELEMENT-TYPE.1 STREAM-ELEMENT-TYPE.2

 STREAM-ELEMENT-TYPE.3 STREAM-ELEMENT-TYPE.4 STREAM-ELEMENT-TYPE.5

 STREAM-ELEMENT-TYPE.6 STREAM-ELEMENT-TYPE.ERROR.1

 STREAM-ELEMENT-TYPE.ERROR.2 STREAM-ELEMENT-TYPE.ERROR.3 STREAMP.1

 STREAMP.2 STREAMP.3 STREAMP.4 STREAMP.ERROR.1 STREAMP.ERROR.2

 READ-BYTE.1 READ-BYTE.2 READ-BYTE.3 READ-BYTE.4 READ-BYTE.ERROR.1

 READ-BYTE.ERROR.2 READ-BYTE.ERROR.3 READ-BYTE.ERROR.4 READ-BYTE.ERROR.5

 READ-BYTE.ERROR.6 WRITE-BYTE.ERROR.1 WRITE-BYTE.ERROR.2

 WRITE-BYTE.ERROR.3 WRITE-BYTE.ERROR.4 WRITE-BYTE.ERROR.5 PEEK-CHAR.1

 PEEK-CHAR.2 PEEK-CHAR.3 PEEK-CHAR.4 PEEK-CHAR.5 PEEK-CHAR.6 PEEK-CHAR.7

 PEEK-CHAR.8 PEEK-CHAR.9 PEEK-CHAR.10 PEEK-CHAR.11 PEEK-CHAR.12

 PEEK-CHAR.13 PEEK-CHAR.14 PEEK-CHAR.15 PEEK-CHAR.16 PEEK-CHAR.17

 PEEK-CHAR.18 PEEK-CHAR.19 PEEK-CHAR.20 PEEK-CHAR.21 PEEK-CHAR.22

 PEEK-CHAR.23 PEEK-CHAR.ERROR.1 PEEK-CHAR.ERROR.2 PEEK-CHAR.ERROR.3

 PEEK-CHAR.ERROR.4 PEEK-CHAR.ERROR.5 READ-CHAR.1 READ-CHAR.2 READ-CHAR.3

 READ-CHAR.4 READ-CHAR.5 READ-CHAR.6 READ-CHAR.7 READ-CHAR.8 READ-CHAR.9

 READ-CHAR.10 READ-CHAR.ERROR.1 READ-CHAR.ERROR.2 READ-CHAR.ERROR.3

 READ-CHAR.ERROR.4 READ-CHAR-NO-HANG.1 READ-CHAR-NO-HANG.2

 READ-CHAR-NO-HANG.3 READ-CHAR-NO-HANG.4 READ-CHAR-NO-HANG.5

 READ-CHAR-NO-HANG.6 READ-CHAR-NO-HANG.7 READ-CHAR-NO-HANG.8

 READ-CHAR-NO-HANG.9 READ-CHAR-NO-HANG.10 READ-CHAR-NO-HANG.ERROR.1

 READ-CHAR-NO-HANG.ERROR.2 READ-CHAR-NO-HANG.ERROR.3

 READ-CHAR-NO-HANG.ERROR.4 TERPRI.1 TERPRI.2 TERPRI.3 TERPRI.4 TERPRI.5

 TERPRI.ERROR.1 FRESH-LINE.1 FRESH-LINE.2 FRESH-LINE.3 FRESH-LINE.4

 FRESH-LINE.5 FRESH-LINE.6 FRESH-LINE.7 FRESH-LINE.ERROR.1 UNREAD-CHAR.1

 UNREAD-CHAR.2 UNREAD-CHAR.3 UNREAD-CHAR.4 UNREAD-CHAR.5

 UNREAD-CHAR.ERROR.1 UNREAD-CHAR.ERROR.2 WRITE-CHAR.1 WRITE-CHAR.2

 WRITE-CHAR.3 WRITE-CHAR.ERROR.1 WRITE-CHAR.ERROR.2 READ-LINE.1

 READ-LINE.2 READ-LINE.3 READ-LINE.4 READ-LINE.5 READ-LINE.6 READ-LINE.7

 READ-LINE.8 READ-LINE.ERROR.1 READ-LINE.ERROR.2 READ-LINE.ERROR.3

 READ-LINE.ERROR.4 WRITE-STRING.1 WRITE-STRING.3 WRITE-STRING.4

 WRITE-STRING.5 WRITE-STRING.6 WRITE-STRING.7 WRITE-STRING.8

 WRITE-STRING.9 WRITE-STRING.10 WRITE-STRING.11 WRITE-STRING.12

 WRITE-STRING.13 WRITE-STRING.ERROR.1 WRITE-STRING.ERROR.2

 WRITE-STRING.ERROR.3 WRITE-STRING.ERROR.4 WRITE-LINE.1 WRITE-LINE.3

 WRITE-LINE.4 WRITE-LINE.5 WRITE-LINE.6 WRITE-LINE.7 WRITE-LINE.8

 WRITE-LINE.9 WRITE-LINE.10 WRITE-LINE.11 WRITE-LINE.12 WRITE-LINE.13

 WRITE-LINE.ERROR.1 WRITE-LINE.ERROR.2 WRITE-LINE.ERROR.3

 WRITE-LINE.ERROR.4 READ-SEQUENCE.STRING.1 READ-SEQUENCE.STRING.2

 READ-SEQUENCE.STRING.3 READ-SEQUENCE.STRING.4 READ-SEQUENCE.STRING.5

 READ-SEQUENCE.STRING.6 READ-SEQUENCE.STRING.7 READ-SEQUENCE.STRING.8

 READ-SEQUENCE.STRING.9 READ-SEQUENCE.STRING.10 READ-SEQUENCE.STRING.11

 READ-SEQUENCE.STRING.12 READ-SEQUENCE.BASE-STRING.1

 READ-SEQUENCE.BASE-STRING.2 READ-SEQUENCE.BASE-STRING.3

 READ-SEQUENCE.BASE-STRING.4 READ-SEQUENCE.BASE-STRING.5

 READ-SEQUENCE.BASE-STRING.6 READ-SEQUENCE.BASE-STRING.7

 READ-SEQUENCE.LIST.1 READ-SEQUENCE.LIST.2 READ-SEQUENCE.LIST.3

 READ-SEQUENCE.LIST.4 READ-SEQUENCE.LIST.5 READ-SEQUENCE.LIST.6

 READ-SEQUENCE.LIST.7 READ-SEQUENCE.VECTOR.1 READ-SEQUENCE.VECTOR.2

 READ-SEQUENCE.VECTOR.3 READ-SEQUENCE.VECTOR.4 READ-SEQUENCE.VECTOR.5

 READ-SEQUENCE.VECTOR.6 READ-SEQUENCE.VECTOR.7

 READ-SEQUENCE.FILL-VECTOR.1 READ-SEQUENCE.FILL-VECTOR.2

 READ-SEQUENCE.FILL-VECTOR.3 READ-SEQUENCE.FILL-VECTOR.4

 READ-SEQUENCE.FILL-VECTOR.5 READ-SEQUENCE.FILL-VECTOR.6

 READ-SEQUENCE.FILL-VECTOR.7 READ-SEQUENCE.FILL-VECTOR.8

 READ-SEQUENCE.BV.1 READ-SEQUENCE.BV.2 READ-SEQUENCE.BV.3

 READ-SEQUENCE.BV.4 READ-SEQUENCE.BV.5 READ-SEQUENCE.BV.6

 READ-SEQUENCE.BV.7 READ-SEQUENCE.ERROR.1 READ-SEQUENCE.ERROR.2

 READ-SEQUENCE.ERROR.3 READ-SEQUENCE.ERROR.4 READ-SEQUENCE.ERROR.5

 READ-SEQUENCE.ERROR.6 READ-SEQUENCE.ERROR.7 READ-SEQUENCE.ERROR.8

 READ-SEQUENCE.ERROR.9 READ-SEQUENCE.ERROR.10 READ-SEQUENCE.ERROR.11

 WRITE-SEQUENCE.STRING.1 WRITE-SEQUENCE.STRING.2 WRITE-SEQUENCE.STRING.3

 WRITE-SEQUENCE.STRING.4 WRITE-SEQUENCE.STRING.5 WRITE-SEQUENCE.STRING.6

 WRITE-SEQUENCE.STRING.7 WRITE-SEQUENCE.STRING.8 WRITE-SEQUENCE.STRING.9

 WRITE-SEQUENCE.STRING.10 WRITE-SEQUENCE.STRING.11

 WRITE-SEQUENCE.STRING.12 WRITE-SEQUENCE.STRING.13

 WRITE-SEQUENCE.STRING.14 WRITE-SEQUENCE.STRING.15 WRITE-SEQUENCE.LIST.1

 WRITE-SEQUENCE.LIST.2 WRITE-SEQUENCE.LIST.3 WRITE-SEQUENCE.LIST.4

 WRITE-SEQUENCE.LIST.5 WRITE-SEQUENCE.LIST.6 WRITE-SEQUENCE.LIST.7

 WRITE-SEQUENCE.LIST.8 WRITE-SEQUENCE.SIMPLE-VECTOR.1

 WRITE-SEQUENCE.SIMPLE-VECTOR.2 WRITE-SEQUENCE.SIMPLE-VECTOR.3

 WRITE-SEQUENCE.SIMPLE-VECTOR.4 WRITE-SEQUENCE.SIMPLE-VECTOR.5

 WRITE-SEQUENCE.SIMPLE-VECTOR.6 WRITE-SEQUENCE.SIMPLE-VECTOR.7

 WRITE-SEQUENCE.SIMPLE-VECTOR.8 WRITE-SEQUENCE.FILL-VECTOR.1

 WRITE-SEQUENCE.FILL-VECTOR.2 WRITE-SEQUENCE.FILL-VECTOR.3

 WRITE-SEQUENCE.FILL-VECTOR.4 WRITE-SEQUENCE.FILL-VECTOR.5

 WRITE-SEQUENCE.FILL-VECTOR.6 WRITE-SEQUENCE.FILL-VECTOR.7

 WRITE-SEQUENCE.BV.1 WRITE-SEQUENCE.BV.2 WRITE-SEQUENCE.BV.3

 WRITE-SEQUENCE.BV.4 WRITE-SEQUENCE.BV.5 WRITE-SEQUENCE.BV.6

 WRITE-SEQUENCE.ERROR.1 WRITE-SEQUENCE.ERROR.2 WRITE-SEQUENCE.ERROR.3

 WRITE-SEQUENCE.ERROR.4 WRITE-SEQUENCE.ERROR.5 WRITE-SEQUENCE.ERROR.6

 WRITE-SEQUENCE.ERROR.7 WRITE-SEQUENCE.ERROR.8 WRITE-SEQUENCE.ERROR.9

 WRITE-SEQUENCE.ERROR.10 WRITE-SEQUENCE.ERROR.11 WRITE-SEQUENCE.ERROR.12

 WRITE-SEQUENCE.ERROR.13 WRITE-SEQUENCE.ERROR.14 WRITE-SEQUENCE.ERROR.15

 WRITE-SEQUENCE.ERROR.16 FILE-LENGTH.ERROR.1 FILE-LENGTH.ERROR.2

 FILE-LENGTH.ERROR.3 FILE-LENGTH.ERROR.4 FILE-LENGTH.ERROR.5

 FILE-LENGTH.ERROR.6 FILE-LENGTH.ERROR.8 FILE-LENGTH.ERROR.9

 FILE-LENGTH.ERROR.10 FILE-LENGTH.ERROR.11 FILE-LENGTH.ERROR.12

 FILE-LENGTH.1 FILE-LENGTH.2 FILE-LENGTH.3 FILE-LENGTH.4 FILE-LENGTH.5

 FILE-LENGTH.6 FILE-POSITION.1 FILE-POSITION.2 FILE-POSITION.3

 FILE-POSITION.4 FILE-POSITION.5 FILE-POSITION.6 FILE-POSITION.7

 FILE-POSITION.8 FILE-POSITION.9 FILE-POSITION.10 FILE-POSITION.ERROR.1

 FILE-POSITION.ERROR.2 FILE-STRING-LENGTH.1 FILE-STRING-LENGTH.2

 FILE-STRING-LENGTH.3 FILE-STRING-LENGTH.ERROR.1

 FILE-STRING-LENGTH.ERROR.2 FILE-STRING-LENGTH.ERROR.3 OPEN.1 OPEN.2

 OPEN.3 OPEN.4 OPEN.5 OPEN.6 OPEN.7 OPEN.8 OPEN.9 OPEN.10 OPEN.11

 OPEN.12 OPEN.13 OPEN.14 OPEN.15 OPEN.16 OPEN.17 OPEN.18 OPEN.19 OPEN.20

 OPEN.21 OPEN.22 OPEN.23 OPEN.24 OPEN.25 OPEN.26 OPEN.27 OPEN.28 OPEN.29

 OPEN.30 OPEN.31 OPEN.32 OPEN.33 OPEN.34 OPEN.35 OPEN.36 OPEN.37 OPEN.38

 OPEN.39 OPEN.40 OPEN.41 OPEN.42 OPEN.43 OPEN.44 OPEN.45 OPEN.46 OPEN.47

 OPEN.48 OPEN.49 OPEN.50 OPEN.51 OPEN.52 OPEN.53 OPEN.54 OPEN.55 OPEN.56

 OPEN.57 OPEN.58 OPEN.59 OPEN.60 OPEN.61 OPEN.62 OPEN.63 OPEN.64 OPEN.65

 OPEN.66 OPEN.67 OPEN.OUTPUT.1 OPEN.OUTPUT.2 OPEN.OUTPUT.3 OPEN.OUTPUT.4

 OPEN.OUTPUT.5 OPEN.OUTPUT.6 OPEN.OUTPUT.7 OPEN.OUTPUT.8 OPEN.OUTPUT.9

 OPEN.OUTPUT.10 OPEN.OUTPUT.11 OPEN.OUTPUT.12 OPEN.OUTPUT.13

 OPEN.OUTPUT.14 OPEN.OUTPUT.15 OPEN.OUTPUT.16 OPEN.OUTPUT.17

 OPEN.OUTPUT.18 OPEN.OUTPUT.19 OPEN.OUTPUT.20 OPEN.OUTPUT.21

 OPEN.OUTPUT.22 OPEN.OUTPUT.23 OPEN.OUTPUT.24 OPEN.OUTPUT.25

 OPEN.OUTPUT.26 OPEN.OUTPUT.27 OPEN.OUTPUT.28 OPEN.OUTPUT.28A

 OPEN.OUTPUT.29 OPEN.OUTPUT.30 OPEN.OUTPUT.31 OPEN.OUTPUT.32

 OPEN.OUTPUT.33 OPEN.OUTPUT.34 OPEN.OUTPUT.35 OPEN.IO.1 OPEN.IO.2

 OPEN.IO.3 OPEN.IO.4 OPEN.IO.5 OPEN.IO.6 OPEN.IO.7 OPEN.IO.8 OPEN.IO.9

 OPEN.IO.10 OPEN.IO.11 OPEN.IO.12 OPEN.IO.13 OPEN.IO.14 OPEN.IO.15

 OPEN.IO.16 OPEN.IO.17 OPEN.IO.18 OPEN.IO.19 OPEN.IO.20 OPEN.IO.21

 OPEN.IO.22 OPEN.IO.23 OPEN.IO.24 OPEN.IO.25 OPEN.IO.26 OPEN.IO.27

 OPEN.IO.28 OPEN.IO.28A OPEN.IO.29 OPEN.IO.30 OPEN.IO.31 OPEN.IO.32

 OPEN.IO.33 OPEN.IO.34 OPEN.IO.35 OPEN.PROBE.1 OPEN.PROBE.2 OPEN.PROBE.3

 OPEN.PROBE.4 OPEN.PROBE.5 OPEN.PROBE.6 OPEN.PROBE.7 OPEN.PROBE.8

 OPEN.PROBE.9 OPEN.PROBE.10 OPEN.PROBE.11 OPEN.PROBE.12 OPEN.PROBE.13

 OPEN.PROBE.14 OPEN.PROBE.15 OPEN.PROBE.16 OPEN.PROBE.17 OPEN.PROBE.18

 OPEN.PROBE.19 OPEN.PROBE.20 OPEN.PROBE.21 OPEN.PROBE.22 OPEN.PROBE.23

 OPEN.PROBE.24 OPEN.PROBE.25 OPEN.PROBE.26 OPEN.PROBE.27 OPEN.PROBE.28

 OPEN.PROBE.29 OPEN.PROBE.30 OPEN.PROBE.31 OPEN.PROBE.32 OPEN.PROBE.33

 OPEN.PROBE.34 OPEN.PROBE.35 OPEN.PROBE.36 OPEN.ERROR.1 OPEN.ERROR.2

 OPEN.ERROR.3 OPEN.ERROR.4 OPEN.ERROR.5 OPEN.ERROR.6 OPEN.ERROR.7

 OPEN.ERROR.8 OPEN.ERROR.9 OPEN.ERROR.10 OPEN.ERROR.11 OPEN.ERROR.12

 OPEN.ERROR.13 OPEN.ERROR.14 OPEN.ERROR.15 OPEN.ERROR.16 OPEN.ERROR.17

 OPEN.ERROR.18 STREAM-EXTERNAL-FORMAT.ERROR.1

 STREAM-EXTERNAL-FORMAT.ERROR.2 WITH-OPEN-FILE.1 WITH-OPEN-FILE.2

 WITH-OPEN-FILE.3 WITH-OPEN-FILE.4 WITH-OPEN-FILE.5 WITH-OPEN-FILE.6

 WITH-OPEN-FILE.7 WITH-OPEN-FILE.8 WITH-OPEN-FILE.9 WITH-OPEN-FILE.10

 WITH-OPEN-STREAM.1 WITH-OPEN-STREAM.2 WITH-OPEN-STREAM.3

 WITH-OPEN-STREAM.4 WITH-OPEN-STREAM.5 WITH-OPEN-STREAM.6

 WITH-OPEN-STREAM.7 WITH-OPEN-STREAM.8 WITH-OPEN-STREAM.9

 WITH-OPEN-STREAM.10 LISTEN.1 LISTEN.2 LISTEN.3 LISTEN.4 LISTEN.6

 LISTEN.7 LISTEN.8 LISTEN.9 LISTEN.ERROR.1 LISTEN.ERROR.2

Test CLEAR-INPUT.1 failed

Form: (LOOP FOR

            S

            IN

            (LIST *DEBUG-IO* *QUERY-IO* *STANDARD-INPUT* *TERMINAL-IO*)

            ALWAYS

            (EQ (CLEAR-INPUT S) NIL))

Expected value: T

Actual value: #<a SIMPLE-ERROR>.

Test CLEAR-INPUT.2 failed

Form: (CLEAR-INPUT)

Expected value: NIL

Actual value: #<a SIMPLE-ERROR>.

Test CLEAR-INPUT.3 failed

Form: (CLEAR-INPUT NIL)

Expected value: NIL

Actual value: #<a SIMPLE-ERROR>.

Test CLEAR-INPUT.4 failed

Form: (CLEAR-INPUT T)

Expected value: NIL

Actual value: #<a SIMPLE-ERROR>.

 CLEAR-INPUT.5 CLEAR-INPUT.6 CLEAR-INPUT.ERROR.1 CLEAR-INPUT.ERROR.2

 CLEAR-INPUT.ERROR.3 CLEAR-INPUT.ERROR.4 CLEAR-INPUT.ERROR.5

 FINISH-OUTPUT.1 FINISH-OUTPUT.2 FINISH-OUTPUT.3 FINISH-OUTPUT.4

 FINISH-OUTPUT.5 FINISH-OUTPUT.6 FINISH-OUTPUT.ERROR.1

 FINISH-OUTPUT.ERROR.2 FINISH-OUTPUT.ERROR.3 FORCE-OUTPUT.1

 FORCE-OUTPUT.2 FORCE-OUTPUT.3 FORCE-OUTPUT.4 FORCE-OUTPUT.5

 FORCE-OUTPUT.6 FORCE-OUTPUT.ERROR.1 FORCE-OUTPUT.ERROR.2

 FORCE-OUTPUT.ERROR.3 CLEAR-OUTPUT.1 CLEAR-OUTPUT.2 CLEAR-OUTPUT.3

 CLEAR-OUTPUT.4 CLEAR-OUTPUT.5 CLEAR-OUTPUT.6 CLEAR-OUTPUT.ERROR.1

 CLEAR-OUTPUT.ERROR.2 CLEAR-OUTPUT.ERROR.3 MAKE-SYNONYM-STREAM.1

 MAKE-SYNONYM-STREAM.3 MAKE-SYNONYM-STREAM.4 MAKE-SYNONYM-STREAM.ERROR.1

 MAKE-SYNONYM-STREAM.ERROR.2 MAKE-SYNONYM-STREAM.ERROR.3

 SYNONYM-STREAM-SYMBOL.1 SYNONYM-STREAM-SYMBOL.ERROR.1

 SYNONYM-STREAM-SYMBOL.ERROR.2 MAKE-BROADCAST-STREAM.1

 MAKE-BROADCAST-STREAM.2 MAKE-BROADCAST-STREAM.3 MAKE-BROADCAST-STREAM.4

 MAKE-BROADCAST-STREAM.5 MAKE-BROADCAST-STREAM.6 MAKE-BROADCAST-STREAM.7

 MAKE-BROADCAST-STREAM.8 MAKE-BROADCAST-STREAM.ERROR.1

 MAKE-BROADCAST-STREAM.ERROR.2 BROADCAST-STREAM-STREAMS.1

 BROADCAST-STREAM-STREAMS.2 BROADCAST-STREAM-STREAMS.ERROR.1

 BROADCAST-STREAM-STREAMS.ERROR.2 MAKE-TWO-WAY-STREAM.1

 MAKE-TWO-WAY-STREAM.2 MAKE-TWO-WAY-STREAM.3 MAKE-TWO-WAY-STREAM.4

 MAKE-TWO-WAY-STREAM.5 MAKE-TWO-WAY-STREAM.6 MAKE-TWO-WAY-STREAM.7

 MAKE-TWO-WAY-STREAM.8 MAKE-TWO-WAY-STREAM.9 MAKE-TWO-WAY-STREAM.10

 MAKE-TWO-WAY-STREAM.11 MAKE-TWO-WAY-STREAM.12 MAKE-TWO-WAY-STREAM.13

 MAKE-TWO-WAY-STREAM.14 MAKE-TWO-WAY-STREAM.ERROR.1

 MAKE-TWO-WAY-STREAM.ERROR.2 MAKE-TWO-WAY-STREAM.ERROR.3

 MAKE-TWO-WAY-STREAM.ERROR.4 MAKE-TWO-WAY-STREAM.ERROR.5

 MAKE-TWO-WAY-STREAM.ERROR.6 MAKE-TWO-WAY-STREAM.ERROR.7

 TWO-WAY-STREAM-INPUT-STREAM.1 TWO-WAY-STREAM-INPUT-STREAM.ERROR.1

 TWO-WAY-STREAM-INPUT-STREAM.ERROR.2 TWO-WAY-STREAM-OUTPUT-STREAM.1

 TWO-WAY-STREAM-OUTPUT-STREAM.ERROR.1

 TWO-WAY-STREAM-OUTPUT-STREAM.ERROR.2 ECHO-STREAM-INPUT-STREAM.1

 ECHO-STREAM-INPUT-STREAM.ERROR.1 ECHO-STREAM-INPUT-STREAM.ERROR.2

 ECHO-STREAM-OUTPUT-STREAM.1 ECHO-STREAM-OUTPUT-STREAM.ERROR.1

 ECHO-STREAM-OUTPUT-STREAM.ERROR.2 MAKE-ECHO-STREAM.1 MAKE-ECHO-STREAM.2

 MAKE-ECHO-STREAM.3 MAKE-ECHO-STREAM.4 MAKE-ECHO-STREAM.5

 MAKE-ECHO-STREAM.6 MAKE-ECHO-STREAM.7 MAKE-ECHO-STREAM.8

 MAKE-ECHO-STREAM.9 MAKE-ECHO-STREAM.10 MAKE-ECHO-STREAM.11

 MAKE-ECHO-STREAM.12 MAKE-ECHO-STREAM.13 MAKE-ECHO-STREAM.14

 MAKE-ECHO-STREAM.15 MAKE-ECHO-STREAM.16 MAKE-ECHO-STREAM.17

 MAKE-ECHO-STREAM.18 MAKE-ECHO-STREAM.20 MAKE-ECHO-STREAM.21

 MAKE-ECHO-STREAM.22 MAKE-ECHO-STREAM.ERROR.1 MAKE-ECHO-STREAM.ERROR.2

 MAKE-ECHO-STREAM.ERROR.3 CONCATENATED-STREAM-STREAMS.1

 CONCATENATED-STREAM-STREAMS.2 CONCATENATED-STREAM-STREAMS.3

 CONCATENATED-STREAM-STREAMS.4 CONCATENATED-STREAM-STREAMS.5

 CONCATENATED-STREAM-STREAMS.ERROR.1 CONCATENATED-STREAM-STREAMS.ERROR.2

 MAKE-CONCATENATED-STREAM.1 MAKE-CONCATENATED-STREAM.2

 MAKE-CONCATENATED-STREAM.3 MAKE-CONCATENATED-STREAM.4

 MAKE-CONCATENATED-STREAM.5 MAKE-CONCATENATED-STREAM.6

 MAKE-CONCATENATED-STREAM.7 MAKE-CONCATENATED-STREAM.8

 MAKE-CONCATENATED-STREAM.9 MAKE-CONCATENATED-STREAM.10

 MAKE-CONCATENATED-STREAM.11 MAKE-CONCATENATED-STREAM.12

 MAKE-CONCATENATED-STREAM.13 MAKE-CONCATENATED-STREAM.14

 MAKE-CONCATENATED-STREAM.15 MAKE-CONCATENATED-STREAM.16

 MAKE-CONCATENATED-STREAM.17 MAKE-CONCATENATED-STREAM.18

 MAKE-CONCATENATED-STREAM.19 MAKE-CONCATENATED-STREAM.20

 MAKE-CONCATENATED-STREAM.21 MAKE-CONCATENATED-STREAM.22

 MAKE-CONCATENATED-STREAM.23 MAKE-CONCATENATED-STREAM.24

 MAKE-CONCATENATED-STREAM.25 MAKE-CONCATENATED-STREAM.26

 MAKE-CONCATENATED-STREAM.27 MAKE-CONCATENATED-STREAM.28

 MAKE-CONCATENATED-STREAM.28A MAKE-CONCATENATED-STREAM.29

 MAKE-CONCATENATED-STREAM.30 MAKE-CONCATENATED-STREAM.31

 MAKE-CONCATENATED-STREAM.32 MAKE-CONCATENATED-STREAM.33

 MAKE-CONCATENATED-STREAM.ERROR.1 MAKE-CONCATENATED-STREAM.ERROR.2

 GET-OUTPUT-STREAM-STRING.1 GET-OUTPUT-STREAM-STRING.ERROR.1

 GET-OUTPUT-STREAM-STRING.ERROR.2 MAKE-STRING-INPUT-STREAM.1

 MAKE-STRING-INPUT-STREAM.2 MAKE-STRING-INPUT-STREAM.3

 MAKE-STRING-INPUT-STREAM.4 MAKE-STRING-INPUT-STREAM.5

 MAKE-STRING-INPUT-STREAM.6 MAKE-STRING-INPUT-STREAM.7

 MAKE-STRING-INPUT-STREAM.8 MAKE-STRING-INPUT-STREAM.9

 MAKE-STRING-INPUT-STREAM.ERROR.1 MAKE-STRING-INPUT-STREAM.ERROR.2

 MAKE-STRING-OUTPUT-STREAM.1 MAKE-STRING-OUTPUT-STREAM.2

 MAKE-STRING-OUTPUT-STREAM.3 MAKE-STRING-OUTPUT-STREAM.5

 MAKE-STRING-OUTPUT-STREAM.6 MAKE-STRING-OUTPUT-STREAM.7

 MAKE-STRING-OUTPUT-STREAM.8 MAKE-STRING-OUTPUT-STREAM.9

 MAKE-STRING-OUTPUT-STREAM.10 MAKE-STRING-OUTPUT-STREAM.13

 MAKE-STRING-OUTPUT-STREAM.ERROR.1 MAKE-STRING-OUTPUT-STREAM.ERROR.2

 MAKE-STRING-OUTPUT-STREAM.ERROR.3 WITH-INPUT-FROM-STRING.1

 WITH-INPUT-FROM-STRING.2 WITH-INPUT-FROM-STRING.3

 WITH-INPUT-FROM-STRING.3A WITH-INPUT-FROM-STRING.4

 WITH-INPUT-FROM-STRING.5 WITH-INPUT-FROM-STRING.6

 WITH-INPUT-FROM-STRING.7 WITH-INPUT-FROM-STRING.9

 WITH-INPUT-FROM-STRING.11 WITH-INPUT-FROM-STRING.12

 WITH-INPUT-FROM-STRING.13 WITH-INPUT-FROM-STRING.14

 WITH-INPUT-FROM-STRING.15 WITH-INPUT-FROM-STRING.16

 WITH-INPUT-FROM-STRING.17 WITH-INPUT-FROM-STRING.18

 WITH-INPUT-FROM-STRING.19 WITH-INPUT-FROM-STRING.20

 WITH-INPUT-FROM-STRING.21 WITH-INPUT-FROM-STRING.22

 WITH-INPUT-FROM-STRING.23 WITH-INPUT-FROM-STRING.24

 WITH-INPUT-FROM-STRING.25 WITH-OUTPUT-TO-STRING.1

 WITH-OUTPUT-TO-STRING.2 WITH-OUTPUT-TO-STRING.3 WITH-OUTPUT-TO-STRING.5

 WITH-OUTPUT-TO-STRING.6 WITH-OUTPUT-TO-STRING.7 WITH-OUTPUT-TO-STRING.8

 WITH-OUTPUT-TO-STRING.10 WITH-OUTPUT-TO-STRING.11

 WITH-OUTPUT-TO-STRING.12 WITH-OUTPUT-TO-STRING.13

 WITH-OUTPUT-TO-STRING.14 WITH-OUTPUT-TO-STRING.15

 WITH-OUTPUT-TO-STRING.16 STREAM-ERROR-STREAM.1

 STREAM-ERROR-STREAM.ERROR.1 STREAM-ERROR-STREAM.ERROR.2

 COPY-PPRINT-DISPATCH.1 COPY-PPRINT-DISPATCH.2 COPY-PPRINT-DISPATCH.3

 COPY-PPRINT-DISPATCH.4 COPY-PPRINT-DISPATCH.5 COPY-PPRINT-DISPATCH.6

 COPY-PPRINT-DISPATCH.7 COPY-PPRINT-DISPATCH.8

 COPY-PPRINT-DISPATCH.ERROR.1 COPY-PPRINT-DISPATCH.ERROR.2

 PRINT.INTEGERS.1 PRINT.INTEGERS.2 PRINT.INTEGERS.3 PRINT.INTEGERS.4

 PRINT.INTEGERS.5 PRINT.INTEGERS.6 PRINT.INTEGERS.7 PRINT.INTEGERS.8

 PRINT.INTEGERS.9 PRINT.INTEGERS.10 PRINT.INTEGERS.11 PRINT.INTEGERS.12

 PRINT.INTEGERS.13 PRINT.INTEGERS.14 PRINT.INTEGERS.15 PRINT.INTEGERS.16

 PRINT.INTEGERS.17 PRINT.INTEGERS.18 PRINT.INTEGERS.19 PRINT.INTEGERS.20

 PRINT.INTEGERS.21 PRINT.INTEGERS.BASE.2.0 PRINT.INTEGERS.BASE.2.1

 PRINT.INTEGERS.BASE.2.2 PRINT.INTEGERS.BASE.2.3 PRINT.INTEGERS.BASE.2.4

 PRINT.INTEGERS.BASE.2.5 PRINT.INTEGERS.BASE.2.6 PRINT.INTEGERS.BASE.2.7

 PRINT.INTEGERS.BASE.2.8 PRINT.INTEGERS.BASE.2.9

 PRINT.INTEGERS.BASE.2.10 PRINT.INTEGERS.BASE.3.0

 PRINT.INTEGERS.BASE.3.1 PRINT.INTEGERS.BASE.3.2 PRINT.INTEGERS.BASE.3.3

 PRINT.INTEGERS.BASE.3.4 PRINT.INTEGERS.BASE.3.5 PRINT.INTEGERS.BASE.3.6

 PRINT.INTEGERS.BASE.3.7 PRINT.INTEGERS.BASE.3.8 PRINT.INTEGERS.BASE.3.9

 PRINT.INTEGERS.BASE.3.10 PRINT.INTEGERS.BASE.4.0

 PRINT.INTEGERS.BASE.4.1 PRINT.INTEGERS.BASE.4.2 PRINT.INTEGERS.BASE.4.3

 PRINT.INTEGERS.BASE.4.4 PRINT.INTEGERS.BASE.4.5 PRINT.INTEGERS.BASE.4.6

 PRINT.INTEGERS.BASE.4.7 PRINT.INTEGERS.BASE.4.8 PRINT.INTEGERS.BASE.4.9

 PRINT.INTEGERS.BASE.4.10 PRINT.INTEGERS.BASE.4.11

 PRINT.INTEGERS.BASE.4.12 PRINT.INTEGERS.BASE.4.13

 PRINT.INTEGERS.BASE.4.14 PRINT.INTEGERS.BASE.7.0

 PRINT.INTEGERS.BASE.7.1 PRINT.INTEGERS.BASE.7.2 PRINT.INTEGERS.BASE.7.3

 PRINT.INTEGERS.BASE.7.4 PRINT.INTEGERS.BASE.7.5 PRINT.INTEGERS.BASE.7.6

 PRINT.INTEGERS.BASE.7.7 PRINT.INTEGERS.BASE.7.8 PRINT.INTEGERS.BASE.7.9

 PRINT.INTEGERS.BASE.11.0 PRINT.INTEGERS.BASE.11.1

 PRINT.INTEGERS.BASE.11.2 PRINT.INTEGERS.BASE.11.3

 PRINT.INTEGERS.BASE.11.4 PRINT.INTEGERS.BASE.11.5

 PRINT.INTEGERS.BASE.11.6 PRINT.INTEGERS.BASE.11.7

 PRINT.INTEGERS.BASE.11.8 PRINT.INTEGERS.BASE.11.9

 PRINT.INTEGERS.BASE.11.10 PRINT.INTEGERS.BASE.11.11

 PRINT.INTEGERS.BASE.16.0 PRINT.INTEGERS.BASE.16.1

 PRINT.INTEGERS.BASE.16.2 PRINT.INTEGERS.BASE.16.3

 PRINT.INTEGERS.BASE.16.4 PRINT.INTEGERS.BASE.16.5

 PRINT.INTEGERS.BASE.16.6 PRINT.INTEGERS.BASE.16.7

 PRINT.INTEGERS.BASE.16.8 PRINT.INTEGERS.BASE.16.9

 PRINT.INTEGERS.BASE.16.10 PRINT.INTEGERS.BASE.16.11

 PRINT.INTEGERS.BASE.36.0 PRINT.INTEGERS.BASE.36.1

 PRINT.INTEGERS.BASE.36.2 PRINT.INTEGERS.BASE.36.3

 PRINT.INTEGERS.BASE.36.4 PRINT.INTEGERS.BASE.36.5

 PRINT.INTEGERS.BASE.36.6 PRINT.INTEGERS.BASE.36.7

 PRINT.INTEGERS.BASE.36.8 PRINT.INTEGERS.BASE.36.9

 PRINT.INTEGERS.BASE.36.10 PRINT.INTEGERS.BASE.36.11

 PRINT.INTEGERS.BASE.36.12 PRINT.INTEGERS.RADIX.0 PRINT.INTEGERS.RADIX.1

 PRINT.INTEGERS.RADIX.2 PRINT.INTEGERS.RADIX.3 PRINT.INTEGERS.RADIX.4

 PRINT.INTEGERS.RADIX.5 PRINT.INTEGERS.RADIX.6

 PRINT.INTEGERS.RADIX.BASE.2.0 PRINT.INTEGERS.RADIX.BASE.2.1

 PRINT.INTEGERS.RADIX.BASE.2.2 PRINT.INTEGERS.RADIX.BASE.2.3

 PRINT.INTEGERS.RADIX.BASE.2.4 PRINT.INTEGERS.RADIX.BASE.2.5

 PRINT.INTEGERS.RADIX.BASE.2.6 PRINT.INTEGERS.RADIX.BASE.2.7

 PRINT.INTEGERS.RADIX.BASE.2.8 PRINT.INTEGERS.RADIX.BASE.2.9

 PRINT.INTEGERS.RADIX.BASE.2.10 PRINT.INTEGERS.RADIX.BASE.3.0

 PRINT.INTEGERS.RADIX.BASE.3.1 PRINT.INTEGERS.RADIX.BASE.3.2

 PRINT.INTEGERS.RADIX.BASE.3.3 PRINT.INTEGERS.RADIX.BASE.3.4

 PRINT.INTEGERS.RADIX.BASE.3.5 PRINT.INTEGERS.RADIX.BASE.3.6

 PRINT.INTEGERS.RADIX.BASE.3.7 PRINT.INTEGERS.RADIX.BASE.3.8

 PRINT.INTEGERS.RADIX.BASE.3.9 PRINT.INTEGERS.RADIX.BASE.3.10

 PRINT.INTEGERS.RADIX.BASE.5.0 PRINT.INTEGERS.RADIX.BASE.5.1

 PRINT.INTEGERS.RADIX.BASE.5.2 PRINT.INTEGERS.RADIX.BASE.5.3

 PRINT.INTEGERS.RADIX.BASE.5.4 PRINT.INTEGERS.RADIX.BASE.5.5

 PRINT.INTEGERS.RADIX.BASE.5.6 PRINT.INTEGERS.RADIX.BASE.5.7

 PRINT.INTEGERS.RADIX.BASE.5.8 PRINT.INTEGERS.RADIX.BASE.5.9

 PRINT.INTEGERS.RADIX.BASE.5.10 PRINT.INTEGERS.RADIX.BASE.8.0

 PRINT.INTEGERS.RADIX.BASE.8.1 PRINT.INTEGERS.RADIX.BASE.8.2

 PRINT.INTEGERS.RADIX.BASE.8.3 PRINT.INTEGERS.RADIX.BASE.8.4

 PRINT.INTEGERS.RADIX.BASE.8.5 PRINT.INTEGERS.RADIX.BASE.8.6

 PRINT.INTEGERS.RADIX.BASE.8.7 PRINT.INTEGERS.RADIX.BASE.8.8

 PRINT.INTEGERS.RADIX.BASE.8.9 PRINT.INTEGERS.RADIX.BASE.8.10

 PRINT.INTEGERS.RADIX.BASE.12.0 PRINT.INTEGERS.RADIX.BASE.12.1

 PRINT.INTEGERS.RADIX.BASE.12.2 PRINT.INTEGERS.RADIX.BASE.12.3

 PRINT.INTEGERS.RADIX.BASE.12.4 PRINT.INTEGERS.RADIX.BASE.12.5

 PRINT.INTEGERS.RADIX.BASE.12.6 PRINT.INTEGERS.RADIX.BASE.12.7

 PRINT.INTEGERS.RADIX.BASE.12.8 PRINT.INTEGERS.RADIX.BASE.12.9

 PRINT.INTEGERS.RADIX.BASE.12.10 PRINT.INTEGERS.RADIX.BASE.16.0

 PRINT.INTEGERS.RADIX.BASE.16.1 PRINT.INTEGERS.RADIX.BASE.16.2

 PRINT.INTEGERS.RADIX.BASE.16.3 PRINT.INTEGERS.RADIX.BASE.16.4

 PRINT.INTEGERS.RADIX.BASE.16.5 PRINT.INTEGERS.RADIX.BASE.16.6

 PRINT.INTEGERS.RADIX.BASE.16.7 PRINT.INTEGERS.RADIX.BASE.16.8

 PRINT.INTEGERS.RADIX.BASE.16.9 PRINT.INTEGERS.RADIX.BASE.16.10

 PRINT.INTEGERS.RADIX.BASE.36.0 PRINT.INTEGERS.RADIX.BASE.36.1

 PRINT.INTEGERS.RADIX.BASE.36.2 PRINT.INTEGERS.RADIX.BASE.36.3

 PRINT.INTEGERS.RADIX.BASE.36.4 PRINT.INTEGERS.RADIX.BASE.36.5

 PRINT.INTEGERS.RADIX.BASE.36.6 PRINT.INTEGERS.RADIX.BASE.36.7

 PRINT.INTEGERS.RADIX.BASE.36.8 PRINT.INTEGERS.RADIX.BASE.36.9

 PRINT.INTEGERS.RADIX.BASE.36.10 PRINT.INTEGERS.BASE.VARIOUS.1

 PRINT.INTEGERS.BASE.VARIOUS.2 PRINT.INTEGERS.BASE.VARIOUS.3

 PRINT.INTEGERS.BASE.VARIOUS.4 PRINT.INTEGERS.RANDOM.1

 PRINT.RATIOS.RANDOM PRINT.SHORT-FLOAT.1 PRINT.SHORT-FLOAT.2

 PRINT.SHORT-FLOAT.3 PRINT.SHORT-FLOAT.4 PRINT.SHORT-FLOAT.RANDOM

 PRINT.SINGLE-FLOAT.1 PRINT.SINGLE-FLOAT.2 PRINT.SINGLE-FLOAT.3

 PRINT.SINGLE-FLOAT.4 PRINT.SINGLE-FLOAT.RANDOM PRINT.DOUBLE-FLOAT.1

 PRINT.DOUBLE-FLOAT.2 PRINT.DOUBLE-FLOAT.3 PRINT.DOUBLE-FLOAT.4

 PRINT.DOUBLE-FLOAT.RANDOM PRINT.LONG-FLOAT.1 PRINT.LONG-FLOAT.2

 PRINT.LONG-FLOAT.3 PRINT.LONG-FLOAT.4 PRINT.LONG-FLOAT.RANDOM

 PRINT.COMPLEX.1 PRINT.COMPLEX.2 PRINT.COMPLEX.RANDOM.1

 PRINT.COMPLEX.RANDOM.2 PRINT.CHAR.1 PRINT.CHAR.2 PRINT.CHAR.3

 PRINT.CHAR.4 PRINT.CHAR.5 PRINT.CHAR.6 PRINT.CHAR.7 PRINT.CHAR.8

 PRINT.CHAR.9 PRINT.CHAR.10 PRINT.CHAR.11 PRINT.SYMBOL.1 PRINT.SYMBOL.2

 PRINT.SYMBOL.3 PRINT.SYMBOL.4 PRINT.SYMBOL.5 PRINT.SYMBOL.6

 PRINT.SYMBOL.7 PRINT.SYMBOL.8 PRINT.SYMBOL.9 PRINT.SYMBOL.10

 PRINT.SYMBOL.11 PRINT.SYMBOL.12 PRINT.SYMBOL.RANDOM.1

 PRINT.SYMBOL.RANDOM.2 PRINT.SYMBOL.RANDOM.3 PRINT.SYMBOL.RANDOM.4

 PRIN1.SYMBOL.1 PRIN1.SYMBOL.2 PRIN1.SYMBOL.3 PRINT.SYMBOL.PREFIX.1

 PRINT.SYMBOL.PREFIX.2 PRINT.SYMBOL.PREFIX.3 PRINT.SYMBOL.PREFIX.4

 PRINT.SYMBOL.PREFIX.5 PRINT.SYMBOL.PREFIX.6 PRINT.SYMBOL.PREFIX.6A

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.EB5.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EB5.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EB5.exp


 PRINT.SYMBOL.PREFIX.6B PRINT.SYMBOL.PREFIX.7 PRINT.SYMBOL.PREFIX.8

 PRINT.SYMBOL.PREFIX.9 PRINT.SYMBOL.PREFIX.10 PRINT.STRING.1

 PRINT.STRING.2 PRINT.STRING.3 PRINT.STRING.4 PRINT.STRING.5

 PRINT.STRING.6 PRINT.STRING.7 PRINT.STRING.8 PRINT.STRING.9

 PRINT.STRING.10 PRINT.STRING.11 PRINT.STRING.12 PRINT.STRING.13

 PRINT.STRING.RANDOM.1 PRINT.CONS.1 PRINT.CONS.2 PRINT.CONS.3

 PRINT.CONS.4 PRINT.CONS.5 PRINT.CONS.6 PRINT.CONS.7 PRINT.CONS.RANDOM.1

 PRINT.CONS.RANDOM.2 PRINT.CONS.LENGTH.1 PRINT.CONS.LENGTH.2

 PRINT.CONS.LENGTH.3 PRINT.CONS.LENGTH.4 PRINT.CONS.LENGTH.5

 PRINT.CONS.LENGTH.6 PRINT.CONS.LEVEL.1 PRINT.CONS.LEVEL.2

 PRINT.CONS.LEVEL.3 PRINT.CONS.LEVEL.4 PRINT.CONS.LEVEL.5

 PRINT.BACKQUOTE.RANDOM.1 PRINT.BACKQUOTE.RANDOM.2

 PRINT.BACKQUOTE.RANDOM.3 PRINT.BACKQUOTE.RANDOM.4

 PRINT.BACKQUOTE.RANDOM.5 PRINT.BACKQUOTE.RANDOM.6

 PRINT.BACKQUOTE.RANDOM.7 PRINT.BACKQUOTE.RANDOM.8

 PRINT.BACKQUOTE.RANDOM.9 PRINT.BACKQUOTE.RANDOM.10

 PRINT.BACKQUOTE.RANDOM.11 PRINT.BACKQUOTE.RANDOM.12

 PRINT.BACKQUOTE.RANDOM.13 PRINT.BACKQUOTE.RANDOM.14 PRINT.BIT-VECTOR.1

 PRINT.BIT-VECTOR.2 PRINT.BIT-VECTOR.3 PRINT.BIT-VECTOR.4

 PRINT.BIT-VECTOR.5 PRINT.BIT-VECTOR.6 PRINT.BIT-VECTOR.7

 PRINT.BIT-VECTOR.RANDOM PRINT.VECTOR.1 PRINT.VECTOR.2 PRINT.VECTOR.3

 PRINT.VECTOR.4 PRINT.VECTOR.5 PRINT.VECTOR.6 PRINT.VECTOR.7

 PRINT.VECTOR.FILL.1 PRINT.VECTOR.FILL.2 PRINT.VECTOR.FILL.3

 PRINT.VECTOR.DISPLACED.1 PRINT.VECTOR.DISPLACED.2

 PRINT.VECTOR.DISPLACED.3 PRINT.VECTOR.ADJUSTABLE.1

 PRINT.VECTOR.ADJUSTABLE.2 PRINT.VECTOR.ADJUSTABLE.3

 PRINT.VECTOR.UNREADABLE.1 PRINT.VECTOR.UNREADABLE.2

 PRINT.VECTOR.UNREADABLE.3 PRINT.VECTOR.RANDOM.1 PRINT.VECTOR.RANDOM.2

 PRINT.VECTOR.RANDOM.3 PRINT.VECTOR.RANDOM.4 PRINT.VECTOR.LENGTH.1

 PRINT.VECTOR.LENGTH.2 PRINT.VECTOR.LENGTH.3 PRINT.VECTOR.LENGTH.4

 PRINT.VECTOR.LENGTH.5 PRINT.VECTOR.LENGTH.6 PRINT.VECTOR.LENGTH.7

 PRINT.VECTOR.LENGTH.8 PRINT.VECTOR.LENGTH.9 PRINT.VECTOR.LEVEL.1

 PRINT.VECTOR.LEVEL.2 PRINT.VECTOR.LEVEL.3 PRINT.VECTOR.LEVEL.4

 PRINT.VECTOR.LEVEL.5 PRINT.VECTOR.LEVEL.6 PRINT.ARRAY.0.1

 PRINT.ARRAY.0.2 PRINT.ARRAY.0.3 PRINT.ARRAY.0.4 PRINT.ARRAY.0.5

 PRINT.ARRAY.0.6 PRINT.ARRAY.0.7 PRINT.ARRAY.0.8 PRINT.ARRAY.0.9

 PRINT.ARRAY.0.10 PRINT.ARRAY.0.11 PRINT.ARRAY.0.12 PRINT.ARRAY.0.13

 PRINT.ARRAY.0.14 PRINT.ARRAY.0.15 PRINT.ARRAY.0.16 PRINT.ARRAY.0.17

 PRINT.ARRAY.2.1 PRINT.ARRAY.2.2 PRINT.ARRAY.2.3 PRINT.ARRAY.2.4

 PRINT.ARRAY.2.5 PRINT.ARRAY.2.6 PRINT.ARRAY.2.7 PRINT.ARRAY.2.8

 PRINT.ARRAY.2.9 PRINT.ARRAY.2.10 PRINT.ARRAY.2.11 PRINT.ARRAY.2.12

 PRINT.ARRAY.2.13 PRINT.ARRAY.2.14 PRINT.ARRAY.2.15 PRINT.ARRAY.2.16

 PRINT.ARRAY.2.17 PRINT.ARRAY.2.20 PRINT.ARRAY.2.21 PRINT.ARRAY.2.22

 PRINT.ARRAY.2.23 PRINT.ARRAY.2.24 PRINT.ARRAY.2.25 PRINT.ARRAY.2.26

 PRINT.ARRAY.2.27 PRINT.ARRAY.2.28 PRINT.ARRAY.2.29 PRINT.ARRAY.2.30

 PRINT.ARRAY.2.31 PRINT.ARRAY.3.1 PRINT.ARRAY.MULTI-DIM.1

 PRINT.ARRAY.MULTI-DIM.2 PRINT.RANDOM-STATE.1 PRINT.PATHNAME.1

 PRINT.PATHNAME.2 PRINT-STRUCTURE.1 PRINT-BASE.INIT.1 PRINT-RADIX.INIT.1

 PRINT-CASE.INIT.1 PRINT-CIRCLE.INIT.1 PRINT-ESCAPE.INIT.1

 PRINT-GENSYM.INIT.1 PRINT-LEVEL.INIT.1 PRINT-LENGTH.INIT.1

 PRINT-LINES.INIT.1 PRINT-READABLY.INIT.1 PRINT-RIGHT-MARGIN.INIT.1

 PPRINT-DISPATCH.1 PPRINT-DISPATCH.3 PPRINT-DISPATCH.4 PPRINT-DISPATCH.5

 PPRINT-DISPATCH.6 PPRINT-DISPATCH.7 PPRINT-DISPATCH.8 PPRINT-DISPATCH.9

 PPRINT-DISPATCH.ERROR.1 PPRINT-DISPATCH.ERROR.2

 SET-PPRINT-DISPATCH.ERROR.1 SET-PPRINT-DISPATCH.ERROR.2

 SET-PPRINT-DISPATCH.ERROR.3 SET-PPRINT-DISPATCH.ERROR.4

 SET-PPRINT-DISPATCH.ERROR.4-UNSAFE PPRINT-FILL.1 PPRINT-FILL.2

 PPRINT-FILL.3 PPRINT-FILL.4 PPRINT-FILL.5 PPRINT-FILL.6 PPRINT-FILL.7

 PPRINT-FILL.8 PPRINT-FILL.9 PPRINT-FILL.10 PPRINT-FILL.11

 PPRINT-FILL.12 PPRINT-FILL.13 PPRINT-FILL.14 PPRINT-FILL.15

 PPRINT-FILL.RETURN-VALUES.1 PPRINT-FILL.RETURN-VALUES.2

 PPRINT-FILL.ERROR.1 PPRINT-FILL.ERROR.2 PPRINT-FILL.ERROR.3

 PPRINT-LINEAR.1 PPRINT-LINEAR.2 PPRINT-LINEAR.3 PPRINT-LINEAR.4

 PPRINT-LINEAR.5 PPRINT-LINEAR.6 PPRINT-LINEAR.7 PPRINT-LINEAR.8

 PPRINT-LINEAR.9 PPRINT-LINEAR.10 PPRINT-LINEAR.11 PPRINT-LINEAR.12

 PPRINT-LINEAR.13 PPRINT-LINEAR.14 PPRINT-LINEAR.ERROR.1

 PPRINT-LINEAR.ERROR.2 PPRINT-LINEAR.ERROR.3 PPRINT-TABULAR.1

 PPRINT-TABULAR.2 PPRINT-TABULAR.3 PPRINT-TABULAR.4 PPRINT-TABULAR.5

 PPRINT-TABULAR.6 PPRINT-TABULAR.7 PPRINT-TABULAR.8 PPRINT-TABULAR.9

 PPRINT-TABULAR.10 PPRINT-TABULAR.11 PPRINT-TABULAR.12 PPRINT-TABULAR.13

 PPRINT-TABULAR.14 PPRINT-TABULAR.15 PPRINT-TABULAR.16 PPRINT-TABULAR.17

 PPRINT-TABULAR.18 PPRINT-TABULAR.19 PPRINT-TABULAR.20 PPRINT-TABULAR.21

 PPRINT-TABULAR.22 PPRINT-TABULAR.23 PPRINT-TABULAR.24

 PPRINT-TABULAR.RETURN-VALUES.1 PPRINT-TABULAR.RETURN-VALUES.2

 PPRINT-TABULAR.ERROR.1 PPRINT-TABULAR.ERROR.2 PPRINT-TABULAR.ERROR.3

 PPRINT-TABULAR.ERROR.4 PPRINT-INDENT.1 PPRINT-INDENT.2 PPRINT-INDENT.3

 PPRINT-INDENT.4 PPRINT-INDENT.5 PPRINT-INDENT.6 PPRINT-INDENT.7

 PPRINT-INDENT.8 PPRINT-INDENT.9 PPRINT-INDENT.10 PPRINT-INDENT.11

 PPRINT-INDENT.12 PPRINT-INDENT.13 PPRINT-INDENT.13A PPRINT-INDENT.14

 PPRINT-INDENT.15 PPRINT-INDENT.16 PPRINT-INDENT.17 PPRINT-INDENT.18

 PPRINT-INDENT.19 PPRINT-INDENT.20 PPRINT-INDENT.21 PPRINT-INDENT.22

 PPRINT-INDENT.23 PPRINT-INDENT.ERROR.1 PPRINT-INDENT.ERROR.2

 PPRINT-INDENT.ERROR.3 PPRINT-INDENT.ERROR.4

 PPRINT-INDENT.ERROR.4-UNSAFE PPRINT-LOGICAL-BLOCK.1

 PPRINT-LOGICAL-BLOCK.2 PPRINT-LOGICAL-BLOCK.3 PPRINT-LOGICAL-BLOCK.4

 PPRINT-LOGICAL-BLOCK.5 PPRINT-LOGICAL-BLOCK.6 PPRINT-LOGICAL-BLOCK.8

 PPRINT-LOGICAL-BLOCK.9 PPRINT-LOGICAL-BLOCK.10 PPRINT-LOGICAL-BLOCK.11

 PPRINT-LOGICAL-BLOCK.12 PPRINT-LOGICAL-BLOCK.13 PPRINT-LOGICAL-BLOCK.14

 PPRINT-LOGICAL-BLOCK.15 PPRINT-LOGICAL-BLOCK.16 PPRINT-LOGICAL-BLOCK.17

 PPRINT-LOGICAL-BLOCK.ERROR.1 PPRINT-LOGICAL-BLOCK.ERROR.1-UNSAFE

 PPRINT-LOGICAL-BLOCK.ERROR.2 PPRINT-LOGICAL-BLOCK.ERROR.2-UNSAFE

 PPRINT-LOGICAL-BLOCK.ERROR.3 PPRINT-LOGICAL-BLOCK.ERROR.3-UNSAFE

 PPRINT-LOGICAL-BLOCK.ERROR.4 PPRINT-LOGICAL-BLOCK.ERROR.4-UNSAFE

 PPRINT-EXIT-IF-LIST-EXHAUSTED.1 PPRINT-EXIT-IF-LIST-EXHAUSTED.2

 PPRINT-EXIT-IF-LIST-EXHAUSTED.3 PPRINT-EXIT-IF-LIST-EXHAUSTED.4

 PPRINT-POP.1 PPRINT-POP.2 PPRINT-POP.3 PPRINT-POP.4 PPRINT-POP.5

 PPRINT-POP.6 PPRINT-POP.7 PPRINT-POP.8 PPRINT-POP.9

 PPRINT-EXIT-IF-LIST-EXHAUSTED.ERROR.1

 PPRINT-EXIT-IF-LIST-EXHAUSTED.ERROR.1-UNSAFE PPRINT-POP.ERROR.1

 PPRINT-POP.ERROR.1-UNSAFE PPRINT-NEWLINE.1 PPRINT-NEWLINE.2

 PPRINT-NEWLINE.3 PPRINT-NEWLINE.LINEAR.1 PPRINT-NEWLINE.LINEAR.2

 PPRINT-NEWLINE.LINEAR.3 PPRINT-NEWLINE.LINEAR.4 PPRINT-NEWLINE.LINEAR.5

 PPRINT-NEWLINE.LINEAR.6 PPRINT-NEWLINE.LINEAR.7 PPRINT-NEWLINE.LINEAR.8

 PPRINT-NEWLINE.LINEAR.9 PPRINT-NEWLINE.LINEAR.10 PPRINT-NEWLINE.MISER.1

 PPRINT-NEWLINE.MISER.2 PPRINT-NEWLINE.MISER.3 PPRINT-NEWLINE.MISER.4

 PPRINT-NEWLINE.MISER.5 PPRINT-NEWLINE.MISER.6 PPRINT-NEWLINE.MISER.7

 PPRINT-NEWLINE.MISER.8 PPRINT-NEWLINE.MISER.9 PPRINT-NEWLINE.MISER.10

 PPRINT-NEWLINE.MISER.11 PPRINT-NEWLINE.MISER.12 PPRINT-NEWLINE.MISER.13

 PPRINT-NEWLINE.FILL.1 PPRINT-NEWLINE.FILL.2 PPRINT-NEWLINE.FILL.3

 PPRINT-NEWLINE.FILL.4 PPRINT-NEWLINE.FILL.5 PPRINT-NEWLINE.FILL.6

 PPRINT-NEWLINE.FILL.7 PPRINT-NEWLINE.FILL.8 PPRINT-NEWLINE.FILL.9

 PPRINT-NEWLINE.FILL.10 PPRINT-NEWLINE.MANDATORY.1

 PPRINT-NEWLINE.MANDATORY.2 PPRINT-NEWLINE.MANDATORY.3

 PPRINT-NEWLINE.MANDATORY.4 PPRINT-NEWLINE.MANDATORY.5

 PPRINT-NEWLINE.MANDATORY.6 PPRINT-NEWLINE.ERROR.1

 PPRINT-NEWLINE.ERROR.1-UNSAFE PPRINT-NEWLINE.ERROR.2

 PPRINT-NEWLINE.ERROR.3 PPRINT-TAB.NON-PRETTY.1 PPRINT-TAB.NON-PRETTY.2

 PPRINT-TAB.NON-PRETTY.3 PPRINT-TAB.NON-PRETTY.4 PPRINT-TAB.NON-PRETTY.5

 PPRINT-TAB.NON-PRETTY.6 PPRINT-TAB.NON-PRETTY.7 PPRINT-TAB.NON-PRETTY.8

 PPRINT-TAB.NIL.1 PPRINT-TAB.T.1 PPRINT-TAB.LINE.1 PPRINT-TAB.SECTION.1

 PPRINT-TAB.LINE-RELATIVE.1 PPRINT-TAB.SECTION-RELATIVE.1

 PPRINT-TAB.ERROR.1 PPRINT-TAB.ERROR.2 PPRINT-TAB.ERROR.3

 PPRINT-TAB.ERROR.4 PPRINT-TAB.ERROR.5 PPRINT-TAB.ERROR.5-UNSAFE

 PRINT-UNREADABLE-OBJECT.1 PRINT-UNREADABLE-OBJECT.2

 PRINT-UNREADABLE-OBJECT.3 PRINT-UNREADABLE-OBJECT.4

 PRINT-UNREADABLE-OBJECT.ERROR.1 PRINT-UNREADABLE-OBJECT.T.1

 PRINT-UNREADABLE-OBJECT.NIL.1 WRITE.1 WRITE.2 WRITE.3 WRITE.4 WRITE.5

 WRITE.6 WRITE.7 WRITE.ERROR.1 WRITE.ERROR.2 WRITE.ERROR.3 WRITE.ERROR.4

 PRINT.1 PRINT.2 PRINT.3 PRINT.ERROR.1 PRINT.ERROR.2 PPRINT.1 PPRINT.2

 PPRINT.3 PPRINT.ERROR.1 PPRINT.ERROR.2 PRIN1.1 PRIN1.2 PRIN1.3

 PRIN1.ERROR.1 PRIN1.ERROR.2 PRINC.1 PRINC.2 PRINC.3 PRINC.ERROR.1

 PRINC.ERROR.2 WRITE-TO-STRING.1 WRITE-TO-STRING.2 WRITE-TO-STRING.3

 WRITE-TO-STRING.4 WRITE-TO-STRING.ERROR.1 WRITE-TO-STRING.ERROR.2

 WRITE-TO-STRING.ERROR.3 PRIN1-TO-STRING.1 PRIN1-TO-STRING.2

 PRIN1-TO-STRING.ERROR.1 PRIN1-TO-STRING.ERROR.2 PRINC-TO-STRING.1

 PRINC-TO-STRING.2 PRINC-TO-STRING.ERROR.1 PRINC-TO-STRING.ERROR.2

 PRINT-LEVEL.3 PRINT-LEVEL.4 PRINT-LEVEL.5 PRINT-LEVEL.8 PRINT-LEVEL.9

 PRINT-LEVEL.12 PRINT-LENGTH.1 PRINT-LENGTH.2 PRINT-LENGTH.3

 PRINT-LENGTH.4 PRINT-LENGTH.5 PRINT-LENGTH.6 PRINT-LENGTH.7

 PRINT-LENGTH.8 PRINT-LENGTH.9 PRINT-LENGTH.10 PRINT-LENGTH.11

 FORMAT.C.1 FORMAT.C.1A FORMAT.C.2 FORMAT.C.2A FORMAT.C.3 FORMATTER.C.3

 FORMAT.C.4 FORMAT.C.4A FORMAT.C.5 FORMAT.C.5A FORMAT.C.6 FORMAT.C.6A

 FORMATTER.C.1 FORMATTER.C.1A FORMATTER.C.2 FORMATTER.C.2A FORMATTER.C.4

 FORMATTER.C.4A FORMATTER.C.5 FORMATTER.C.6 FORMAT.%.1 FORMATTER.%.1

 FORMAT.%.2 FORMAT.%.3 FORMATTER.%.3 FORMAT.%.4 FORMATTER.%.4 FORMAT.%.5

 FORMATTER.%.5 FORMAT.%.6 FORMATTER.%.6 FORMAT.&.1 FORMATTER.&.1

 FORMAT.&.2 FORMATTER.&.2 FORMAT.&.3 FORMATTER.&.3 FORMAT.&.4

 FORMATTER.&.4 FORMAT.&.5 FORMATTER.&.5 FORMAT.&.6 FORMATTER.&.6

 FORMAT.&.7 FORMATTER.&.7 FORMAT.&.8 FORMATTER.&.8 FORMAT.&.9

 FORMATTER.&.9 FORMAT.&.10 FORMATTER.&.10 FORMAT.&.11 FORMATTER.&.11

 FORMAT.&.12 FORMATTER.&.12 FORMAT.&.13 FORMATTER.&.13 FORMAT.PAGE.1

 FORMATTER.PAGE.1 FORMAT.PAGE.2 FORMAT.PAGE.3 FORMAT.PAGE.4

 FORMATTER.PAGE.4 FORMAT.PAGE.5 FORMATTER.PAGE.5 FORMAT.~.1

 FORMATTER.~.1 FORMAT.~.2 FORMATTER.~.2 FORMAT.~.3 FORMATTER.~.3

 FORMAT.~.4 FORMATTER.~.4 FORMAT.~.5 FORMATTER.~.5 FORMAT.R.1

 FORMATTER.R.1 FORMAT.R.2 FORMATTER.R.2 FORMAT.R.3 FORMATTER.R.3

 FORMAT.R.4 FORMATTER.R.4 FORMAT.R.5 FORMATTER.R.5 FORMAT.R.6

 FORMATTER.R.6 FORMAT.R.7 FORMATTER.R.7 FORMAT.R.7A FORMAT.R.8

 FORMATTER.R.8 FORMAT.R.9 FORMATTER.R.9 FORMAT.R.10 FORMATTER.R.10

 FORMAT.R.11 FORMATTER.R.11 FORMAT.R.12 FORMATTER.R.12 FORMAT.R.13

 FORMATTER.R.13 FORMAT.R.14 FORMAT.R.15 FORMAT.R.16 FORMATTER.R.16

 FORMAT.R.17 FORMATTER.R.17 FORMAT.R.18 FORMATTER.R.18 FORMAT.R.18A

 FORMAT.R.19 FORMATTER.R.19 FORMAT.R.20 FORMATTER.R.20 FORMAT.R.21

 FORMAT.R.22 FORMATTER.R.22 FORMAT.R.23 FORMATTER.R.23 FORMAT.R.24

 FORMATTER.R.24 FORMAT.R.25 FORMATTER.R.25 FORMAT.R.26 FORMATTER.R.26

 FORMAT.R.27 FORMATTER.R.27 FORMAT.R.28 FORMATTER.R.28 FORMAT.R.29

 FORMATTER.R.29 FORMAT.R.30 FORMATTER.R.30 FORMAT.R.31 FORMATTER.R.31

 FORMAT.R.32 FORMATTER.R.32 FORMAT.R.33 FORMATTER.R.33 FORMAT.R.34

 FORMATTER.R.34 FORMAT.R.35 FORMATTER.R.35 FORMAT.R.36 FORMATTER.R.36

 FORMAT.R.37 FORMATTER.R.37 FORMAT.R.38 FORMATTER.R.38 FORMAT.R.39

 FORMAT.D.1 FORMATTER.D.1 FORMAT.D.2 FORMATTER.D.2 FORMAT.D.3

 FORMATTER.D.3 FORMAT.D.4 FORMATTER.D.4 FORMAT.D.5 FORMATTER.D.5

 FORMAT.D.6 FORMAT.D.7 FORMAT.D.8 FORMAT.D.9 FORMAT.D.10 FORMAT.D.11

 FORMATTER.D.11 FORMAT.D.12 FORMAT.D.13 FORMAT.D.14 FORMATTER.D.14

 FORMAT.D.15 FORMATTER.D.15 FORMAT.D.16 FORMATTER.D.16 FORMAT.D.17

 FORMATTER.D.17 FORMAT.D.18 FORMAT.D.19 FORMAT.D.20 FORMAT.D.21

 FORMAT.D.22 FORMATTER.D.22 FORMAT.D.23 FORMAT.D.24 FORMAT.D.25

 FORMATTER.D.25 FORMAT.D.26 FORMATTER.D.26 FORMAT.D.27 FORMATTER.D.27

 FORMAT.D.28 FORMATTER.D.28 FORMAT.D.29 FORMATTER.D.29 FORMAT.D.30

 FORMAT.B.1 FORMAT.B.2 FORMAT.B.3 FORMATTER.B.3 FORMAT.B.4 FORMATTER.B.4

 FORMAT.B.5 FORMATTER.B.5 FORMAT.B.6 FORMAT.B.7 FORMAT.B.8 FORMAT.B.9

 FORMAT.B.10 FORMAT.B.11 FORMATTER.B.11 FORMAT.B.12 FORMAT.B.13

 FORMAT.B.14 FORMATTER.B.14 FORMAT.B.15 FORMATTER.B.15 FORMAT.B.16

 FORMATTER.B.16 FORMAT.B.17 FORMATTER.B.17 FORMAT.B.18 FORMAT.B.19

 FORMAT.B.20 FORMAT.B.21 FORMAT.B.22 FORMAT.B.23 FORMAT.B.24 FORMAT.B.25

 FORMATTER.B.25 FORMAT.B.26 FORMATTER.B.26 FORMAT.B.27 FORMATTER.B.27

 FORMAT.B.28 FORMATTER.B.28 FORMAT.B.29 FORMATTER.B.29 FORMAT.B.30

 FORMAT.O.1 FORMAT.O.2 FORMAT.O.3 FORMATTER.O.3 FORMAT.O.4 FORMATTER.O.4

 FORMAT.O.5 FORMATTER.O.5 FORMAT.O.6 FORMAT.O.7 FORMAT.O.8 FORMAT.O.9

 FORMAT.O.10 FORMAT.O.11 FORMATTER.O.11 FORMAT.O.12 FORMAT.O.13

 FORMAT.O.14 FORMATTER.O.14 FORMAT.O.15 FORMATTER.O.15 FORMAT.O.16

 FORMATTER.O.16 FORMAT.O.17 FORMATTER.O.17 FORMAT.O.18 FORMAT.O.19

 FORMAT.O.20 FORMAT.O.21 FORMAT.O.22 FORMAT.O.23 FORMAT.O.24 FORMAT.O.25

 FORMATTER.O.25 FORMAT.O.26 FORMATTER.O.26 FORMAT.O.27 FORMATTER.O.27

 FORMAT.O.28 FORMATTER.O.28 FORMAT.O.29 FORMATTER.O.29 FORMAT.O.30

 FORMAT.X.1 FORMAT.X.2 FORMAT.X.3 FORMATTER.X.3 FORMAT.X.4 FORMATTER.X.4

 FORMAT.X.5 FORMATTER.X.5 FORMAT.X.6 FORMAT.X.7 FORMAT.X.8 FORMAT.X.9

 FORMAT.X.10 FORMAT.X.11 FORMATTER.X.11 FORMAT.X.12 FORMAT.X.13

 FORMAT.X.14 FORMATTER.X.14 FORMAT.X.15 FORMATTER.X.15 FORMAT.X.16

 FORMATTER.X.16 FORMAT.X.17 FORMATTER.X.17 FORMAT.X.18 FORMAT.X.19

 FORMAT.X.20 FORMAT.X.21 FORMAT.X.22 FORMAT.X.23 FORMAT.X.24 FORMAT.X.25

 FORMATTER.X.25 FORMAT.X.26 FORMATTER.X.26 FORMAT.X.27 FORMATTER.X.27

 FORMAT.X.28 FORMATTER.X.28 FORMAT.X.29 FORMATTER.X.29 FORMAT.X.30

 FORMAT.F.1 FORMAT.F.2 FORMAT.F.3 FORMAT.F.4 FORMAT.F.5 FORMAT.F.6

 FORMAT.F.7 FORMAT.F.8 FORMAT.F.9 FORMAT.F.10 FORMAT.F.11 FORMAT.F.12

 FORMAT.F.13 FORMAT.F.14 FORMAT.F.15 FORMAT.F.16 FORMAT.F.17 FORMAT.F.18

 FORMAT.F.19 FORMAT.F.20 FORMAT.F.21 FORMAT.F.22 FORMAT.F.23 FORMAT.F.24

 FORMAT.F.25 FORMAT.F.26 FORMAT.F.27 FORMAT.F.28 FORMAT.F.29 FORMAT.F.30

 FORMAT.F.31 FORMAT.F.32 FORMAT.F.34 FORMAT.F.35 FORMAT.F.36 FORMAT.F.37

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.

;;; Variable +IO-SYNTAX-PROGV-LIST+ was undefined. Compiler assumes it is a global.EB8.c
   Creating library C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EB8.implib and object C:/DOCUME~1/Jjgarcia/LOCALS~1/Temp/EB8.exp


 FORMAT.F.38 FORMAT.F.39 FORMAT.F.40 FORMAT.F.41 FORMAT.F.42 FORMAT.F.43

 FORMATTER.F.43 FORMAT.F.44 FORMAT.A.1 FORMATTER.A.1 FORMAT.A.2

 FORMATTER.A.2 FORMAT.A.3 FORMATTER.A.3 FORMAT.A.4 FORMATTER.A.4

 FORMAT.A.5 FORMATTER.A.5 FORMAT.A.6 FORMATTER.A.6 FORMAT.A.7 FORMAT.A.8

 FORMAT.A.9 FORMAT.A.10 FORMAT.A.11 FORMAT.A.12 FORMAT.A.13 FORMAT.A.14

 FORMAT.A.15 FORMATTER.A.15 FORMAT.A.16 FORMATTER.A.16 FORMAT.A.17

 FORMATTER.A.17 FORMAT.A.18 FORMATTER.A.18 FORMAT.A.19 FORMATTER.A.19

 FORMAT.A.20 FORMATTER.A.20 FORMAT.A.21 FORMATTER.A.21 FORMAT.A.22

 FORMATTER.A.22 FORMAT.A.23 FORMATTER.A.23 FORMAT.A.24 FORMATTER.A.24

 FORMAT.A.25 FORMATTER.A.25 FORMAT.A.26 FORMATTER.A.26 FORMAT.A.27

 FORMATTER.A.27 FORMAT.A.28 FORMATTER.A.28 FORMAT.A.29 FORMAT.A.30

 FORMATTER.A.30 FORMAT.A.31 FORMATTER.A.31 FORMAT.A.32 FORMATTER.A.32

 FORMAT.A.33 FORMATTER.A.33 FORMAT.A.34 FORMATTER.A.34 FORMAT.A.35

 FORMATTER.A.35 FORMAT.A.36 FORMATTER.A.36 FORMAT.A.37 FORMATTER.A.37

 FORMAT.A.38 FORMATTER.A.38 FORMAT.A.39 FORMATTER.A.39 FORMAT.A.40

 FORMATTER.A.40 FORMAT.A.41 FORMATTER.A.41 FORMAT.A.42 FORMATTER.A.42

 FORMAT.A.43 FORMATTER.A.43 FORMAT.A.44 FORMAT.A.44A FORMAT.A.45

 FORMATTER.A.45 FORMAT.A.46 FORMATTER.A.46 FORMAT.A.47 FORMATTER.A.47

 FORMAT.A.48 FORMATTER.A.48 FORMAT.A.49 FORMATTER.A.49 FORMAT.A.50

 FORMATTER.A.50 FORMAT.A.51 FORMATTER.A.51 FORMAT.A.52 FORMATTER.A.52

 FORMAT.A.53 FORMATTER.A.53 FORMAT.A.54 FORMATTER.A.54 FORMAT.A.55

 FORMATTER.A.55 FORMAT.A.56 FORMATTER.A.56 FORMAT.A.57 FORMATTER.A.57

 FORMAT.A.58 FORMATTER.A.58 FORMAT.S.1 FORMATTER.S.1 FORMAT.S.2

 FORMATTER.S.2 FORMAT.S.3 FORMATTER.S.3 FORMAT.S.4 FORMATTER.S.4

 FORMAT.S.5 FORMATTER.S.5 FORMAT.S.6 FORMATTER.S.6 FORMAT.S.7 FORMAT.S.8

 FORMAT.S.9 FORMAT.S.10 FORMAT.S.11 FORMAT.S.12 FORMAT.S.13 FORMAT.S.14

 FORMAT.S.15 FORMATTER.S.15 FORMAT.S.16 FORMATTER.S.16 FORMAT.S.17

 FORMATTER.S.17 FORMAT.S.18 FORMATTER.S.18 FORMAT.S.19 FORMATTER.S.19

 FORMAT.S.20 FORMATTER.S.20 FORMAT.S.21 FORMATTER.S.21 FORMAT.S.22

 FORMATTER.S.22 FORMAT.S.23 FORMATTER.S.23 FORMAT.S.24 FORMATTER.S.24

 FORMAT.S.25 FORMATTER.S.25 FORMAT.S.26 FORMATTER.S.26 FORMAT.S.27

 FORMATTER.S.27 FORMAT.S.28 FORMATTER.S.28 FORMAT.S.29 FORMAT.S.30

 FORMATTER.S.30 FORMAT.S.31 FORMATTER.S.31 FORMAT.S.32 FORMATTER.S.32

 FORMAT.S.33 FORMATTER.S.33 FORMAT.S.34 FORMATTER.S.34 FORMAT.S.35

 FORMATTER.S.35 FORMAT.S.36 FORMATTER.S.36 FORMAT.S.37 FORMATTER.S.37

 FORMAT.S.38 FORMATTER.S.38 FORMAT.S.39 FORMATTER.S.39 FORMAT.S.40

 FORMATTER.S.40 FORMAT.S.41 FORMATTER.S.41 FORMAT.S.42 FORMATTER.S.42

 FORMAT.S.43 FORMATTER.S.43 FORMAT.S.44 FORMAT.S.44A FORMAT.S.45

 FORMATTER.S.45 FORMAT.S.46 FORMATTER.S.46 FORMAT.S.47 FORMATTER.S.47

 FORMAT.S.48 FORMATTER.S.48 FORMAT._.1 FORMAT._.2 FORMAT._.3 FORMAT._.4

 FORMAT._.5 FORMAT._.6 FORMAT._.7 FORMAT._.8 FORMAT._.9 FORMATTER._.9

 FORMAT.@_.1 FORMAT.@_.2 FORMAT.@_.3 FORMAT.@_.4 FORMAT.@_.5 FORMAT.@_.6

 FORMAT.@_.7 FORMAT.@_.8 FORMAT.@_.9 FORMAT.@_.10 FORMATTER.@_.10

 |FORMAT.:_.1| |FORMAT.:_.2| |FORMAT.:_.3| |FORMAT.:_.4| |FORMAT.:_.5|

 |FORMAT.:_.6| |FORMAT.:_.7| |FORMATTER.:_.7| |FORMAT.:@_.1|

 |FORMAT.:@_.2| |FORMAT.:@_.3| |FORMAT.:@_.4| |FORMAT.:@_.5|

 |FORMATTER.:@_.5| FORMAT.LOGICAL-BLOCK.ERROR.1

 FORMAT.LOGICAL-BLOCK.ERROR.2 FORMAT.LOGICAL-BLOCK.ERROR.3

 FORMAT.LOGICAL-BLOCK.ERROR.4 FORMAT.LOGICAL-BLOCK.ERROR.5

 FORMAT.LOGICAL-BLOCK.ERROR.6 FORMAT.LOGICAL-BLOCK.ERROR.7

 FORMAT.LOGICAL-BLOCK.ERROR.8 FORMAT.LOGICAL-BLOCK.ERROR.9

 FORMAT.LOGICAL-BLOCK.ERROR.10 FORMAT.LOGICAL-BLOCK.ERROR.11

 FORMAT.LOGICAL-BLOCK.ERROR.12 FORMAT.LOGICAL-BLOCK.ERROR.13

 FORMAT.LOGICAL-BLOCK.ERROR.14 FORMAT.LOGICAL-BLOCK.ERROR.15

 FORMAT.LOGICAL-BLOCK.ERROR.16 FORMAT.LOGICAL-BLOCK.ERROR.17

 FORMAT.LOGICAL-BLOCK.ERROR.18 FORMAT.LOGICAL-BLOCK.ERROR.19

 FORMAT.LOGICAL-BLOCK.ERROR.20 FORMAT.LOGICAL-BLOCK.ERROR.21

 FORMAT.LOGICAL-BLOCK.ERROR.22 FORMAT.LOGICAL-BLOCK.ERROR.23

 FORMAT.LOGICAL-BLOCK.ERROR.24 FORMAT.LOGICAL-BLOCK.ERROR.25

 FORMAT.LOGICAL-BLOCK.ERROR.26 FORMAT.LOGICAL-BLOCK.ERROR.27

 FORMAT.LOGICAL-BLOCK.1 FORMAT.LOGICAL-BLOCK.2 FORMAT.LOGICAL-BLOCK.3

 FORMAT.LOGICAL-BLOCK.4 FORMAT.LOGICAL-BLOCK.5 FORMAT.LOGICAL-BLOCK.6

 FORMAT.LOGICAL-BLOCK.7 FORMAT.LOGICAL-BLOCK.8 FORMAT.LOGICAL-BLOCK.9

 FORMAT.LOGICAL-BLOCK.10 FORMAT.LOGICAL-BLOCK.11 FORMAT.LOGICAL-BLOCK.12

 FORMAT.LOGICAL-BLOCK.13 FORMAT.LOGICAL-BLOCK.14 FORMAT.LOGICAL-BLOCK.15

 FORMAT.LOGICAL-BLOCK.16 FORMAT.LOGICAL-BLOCK.17 FORMAT.LOGICAL-BLOCK.18

 FORMAT.LOGICAL-BLOCK.19 FORMAT.LOGICAL-BLOCK.20 FORMAT.LOGICAL-BLOCK.21

 FORMAT.LOGICAL-BLOCK.22

Test FORMAT.LOGICAL-BLOCK.23 failed

Form: (WITH-STANDARD-IO-SYNTAX

       (LET ((*PRINT-PRETTY* T)

             (*PRINT-ESCAPE* NIL)

             (*PRINT-READABLY* NIL)

             (*PRINT-RIGHT-MARGIN* 2)

             (*PACKAGE* #<"CL-TEST" package>)

             (*PRINT-LENGTH* NIL)

             (*PRINT-MISER-WIDTH* NIL)

             (*PRINT-CIRCLE* NIL))

         (FORMAT NIL

                 "~:@<~@{~A~^/~

                   ~}~:@>"

                 1

                 2

                 3)))

Expected value: "(1/2/3)"

Actual value: "(1/

 2/

 3)".

 FORMAT.LOGICAL-BLOCK.24 FORMAT.LOGICAL-BLOCK.25 FORMAT.LOGICAL-BLOCK.26

 FORMAT.LOGICAL-BLOCK.27 FORMAT.LOGICAL-BLOCK.28 FORMAT.LOGICAL-BLOCK.29

 FORMAT.LOGICAL-BLOCK.CIRCLE.1 FORMAT.LOGICAL-BLOCK.CIRCLE.2

 FORMAT.LOGICAL-BLOCK.CIRCLE.3 FORMAT.LOGICAL-BLOCK.CIRCLE.4

 FORMAT.LOGICAL-BLOCK.CIRCLE.5 FORMAT.LOGICAL-BLOCK.ESCAPE.1

 FORMAT.LOGICAL-BLOCK.ESCAPE.2 FORMAT.I.1 FORMAT.I.2 FORMAT.I.3

 FORMAT.I.4 FORMAT.I.5 FORMAT.I.6 FORMAT.I.7 FORMAT.I.8 FORMAT.I.9

 FORMAT.I.10 FORMAT.I.11 FORMAT.I.12 FORMAT.I.13 FORMAT.I.14 FORMAT.I.15

 FORMAT.I.16 FORMAT./.1 FORMAT./.2 FORMAT./.3 FORMAT./.4 FORMAT./.5

 FORMAT./.6 FORMAT./.7 FORMAT./.8 FORMAT./.9 FORMAT./.10 FORMAT./.11

 FORMAT./.12 FORMAT./.13 FORMAT./.14 FORMAT./.15 FORMAT./.16 FORMAT./.17

 FORMAT./.18 FORMAT./.19 FORMAT.T.1 FORMAT.T.2 FORMAT.T.3 FORMAT.T.4

 FORMAT.T.5 FORMAT.T.6 FORMAT.T.7 FORMAT.T.8 FORMAT.T.9 FORMAT.T.10

 FORMAT.@T.1 FORMAT.@T.2 FORMAT.@T.3 FORMAT.@T.4 FORMAT.@T.5

 |FORMAT.:T.1| |FORMAT.:T.2| |FORMAT.:T.3| |FORMAT.:T.4| |FORMAT.:T.5|

 |FORMAT.:T.5A| |FORMAT.:T.6| |FORMAT.:T.6A| |FORMAT.:T.6B|

 |FORMAT.:T.7| |FORMAT.:T.8| |FORMAT.:T.9| |FORMAT.:T.10| |FORMAT.:T.11|

 |FORMAT.:T.12| |FORMAT.:T.ERROR.1| |FORMAT.:T.ERROR.2|

 |FORMAT.:T.ERROR.3| |FORMAT.:@T.1| |FORMAT.:@T.1A| |FORMAT.:@T.1B|

 |FORMAT.:@T.1C| |FORMAT.:@T.1D| |FORMAT.:@T.2| |FORMAT.:@T.3|

 |FORMAT.:@T.4| |FORMAT.:@T.5| FORMAT.JUSTIFY.1 FORMAT.JUSTIFY.2

 FORMAT.JUSTIFY.3 FORMAT.JUSTIFY.4 FORMAT.JUSTIFY.5 FORMAT.JUSTIFY.6

 FORMAT.JUSTIFY.7 FORMAT.JUSTIFY.8 FORMAT.JUSTIFY.9 FORMAT.JUSTIFY.10

 FORMAT.JUSTIFY.11 FORMAT.JUSTIFY.12 FORMAT.JUSTIFY.13

 FORMAT.JUSTIFY.13A FORMAT.JUSTIFY.14 FORMAT.JUSTIFY.15

 FORMAT.JUSTIFY.16 FORMAT.JUSTIFY.17 FORMAT.JUSTIFY.18 FORMAT.JUSTIFY.19

 FORMAT.JUSTIFY.20 FORMAT.JUSTIFY.21 FORMAT.JUSTIFY.22 FORMAT.JUSTIFY.23

 FORMAT.JUSTIFY.24 FORMAT.JUSTIFY.25 FORMAT.JUSTIFY.26 FORMAT.JUSTIFY.27

 FORMAT.JUSTIFY.28 FORMAT.JUSTIFY.29 FORMAT.JUSTIFY.30 FORMAT.JUSTIFY.31

 FORMAT.JUSTIFY.32 FORMAT.JUSTIFY.ERROR.W.1 FORMAT.JUSTIFY.ERROR.W.2

 FORMAT.JUSTIFY.ERROR.W.3 FORMAT.JUSTIFY.ERROR._.1

 FORMAT.JUSTIFY.ERROR._.2 FORMAT.JUSTIFY.ERROR._.3

 FORMAT.JUSTIFY.ERROR.I.1 FORMAT.JUSTIFY.ERROR.I.2

 FORMAT.JUSTIFY.ERROR.I.3 FORMAT.*.1 FORMATTER.*.1 FORMAT.*.2

 FORMATTER.*.2 FORMAT.*.3 FORMATTER.*.3 FORMAT.*.4 FORMATTER.*.4

 FORMAT.*.5 FORMATTER.*.5 FORMAT.*.6 FORMATTER.*.6 FORMAT.*.7

 FORMATTER.*.7 FORMAT.*.8 FORMATTER.*.8 FORMAT.*.9 FORMATTER.*.9

 |FORMAT.:*.1| |FORMATTER.:*.1| |FORMAT.:*.2| |FORMATTER.:*.2|

 |FORMAT.:*.3| |FORMATTER.:*.3| |FORMAT.:*.4| |FORMATTER.:*.4|

 |FORMAT.:*.5| |FORMATTER.:*.5| |FORMAT.:*.6| |FORMATTER.:*.6|

 |FORMAT.:*.7| |FORMATTER.:*.7| |FORMAT.:*.8| |FORMATTER.:*.8|

 |FORMAT.:*.9| |FORMATTER.:*.9| |FORMAT.:*.10| |FORMATTER.:*.10|

 |FORMAT.:*.11| |FORMATTER.:*.11| |FORMAT.:*.12| |FORMATTER.:*.12|

 |FORMAT.:*.13| |FORMATTER.:*.13| FORMAT.@*.1 FORMATTER.@*.1 FORMAT.@*.2

 FORMATTER.@*.2 FORMAT.@*.3 FORMATTER.@*.3 FORMAT.@*.4 FORMATTER.@*.4

 FORMAT.@*.5 FORMATTER.@*.5 FORMAT.@*.6 FORMATTER.@*.6 FORMAT.@*.7

 FORMATTER.@*.7 FORMAT.@*.8 FORMATTER.@*.8 FORMAT.@*.9 FORMATTER.@*.9

 FORMAT.@*.10 FORMATTER.@*.10 FORMAT.@*.11 FORMATTER.@*.11 FORMAT.COND.1

 FORMATTER.COND.1 FORMAT.COND.2 FORMATTER.COND.2 FORMAT.COND.3

 FORMATTER.COND.3 FORMAT.COND.4 FORMATTER.COND.4 FORMAT.COND.5

 FORMATTER.COND.5 FORMAT.COND.6 FORMATTER.COND.6 FORMAT.COND.7

 FORMATTER.COND.7 FORMAT.COND.8 FORMATTER.COND.8 FORMAT.COND.9

 FORMATTER.COND.9 FORMAT.COND.10 FORMATTER.COND.10 FORMAT.COND.11

 FORMATTER.COND.11 FORMAT.COND.12 FORMATTER.COND.12 FORMAT.COND.13

 FORMATTER.COND.13 FORMAT.COND.14 FORMATTER.COND.14 FORMAT.COND.15

 FORMATTER.COND.15 FORMAT.COND.16 FORMATTER.COND.16 |FORMAT.COND:.1|

 |FORMATTER.COND:.1| |FORMAT.COND:.2| |FORMATTER.COND:.2|

 |FORMAT.COND:.3| |FORMATTER.COND:.3| |FORMAT.COND:.4|

 |FORMATTER.COND:.4| |FORMAT.COND:.5| |FORMATTER.COND:.5|

 |FORMAT.COND:.6| |FORMATTER.COND:.6| |FORMAT.COND:.7|

 |FORMATTER.COND:.7| |FORMAT.COND:.8| |FORMATTER.COND:.8|

 |FORMAT.COND:.9| |FORMATTER.COND:.9| |FORMAT.:COND.1|

 |FORMATTER.:COND.1| |FORMAT.:COND.2| |FORMATTER.:COND.2| FORMAT.@COND.1

 FORMATTER.@COND.1 FORMAT.@COND.2 FORMATTER.@COND.2 FORMAT.{.1

 FORMATTER.{.1 FORMAT.{.1A FORMATTER.{.1A FORMAT.{.1B FORMATTER.{.1B

 FORMAT.{.2 FORMATTER.{.2 FORMAT.{.3 FORMATTER.{.3 FORMAT.{.4

 FORMATTER.{.4 FORMAT.{.5 FORMATTER.{.5 FORMAT.{.6 FORMATTER.{.6

 FORMAT.{.7 FORMATTER.{.7 FORMAT.{.8 FORMATTER.{.8 FORMAT.{.9

 FORMATTER.{.9 FORMAT.{.15 FORMATTER.{.15 FORMAT.{.16 FORMATTER.{.16

 FORMAT.{.17 FORMAT.{.18 FORMAT.{.19 FORMAT.{.20 FORMAT.{.21

 FORMATTER.{.21 FORMAT.{.22 FORMATTER.{.22 FORMAT.{.23 FORMATTER.{.23

 FORMAT.{.24 FORMATTER.{.24 FORMAT.{.25 FORMATTER.{.25 FORMAT.{.26

 FORMATTER.{.26 FORMAT.{.27 FORMATTER.{.27 FORMAT.{.28 FORMATTER.{.28

 FORMAT.{.29 FORMATTER.{.29 FORMAT.{.30 FORMATTER.{.30 FORMAT.{.31

 FORMATTER.{.31 FORMAT.{.32 FORMATTER.{.32 FORMAT.{.33 FORMATTER.{.33

 |FORMAT.:{.1| |FORMATTER.:{.1| |FORMAT.:{.2| |FORMATTER.:{.2|

 |FORMAT.:{.3| |FORMATTER.:{.3| |FORMAT.:{.4| |FORMATTER.:{.4|

 |FORMAT.:{.5| |FORMATTER.:{.5| |FORMAT.:{.6| |FORMAT.:{.7|

 |FORMATTER.:{.7| |FORMAT.:{.8| |FORMATTER.:{.8| |FORMAT.:{.9|

 |FORMATTER.:{.9| |FORMAT.:{.10| |FORMATTER.:{.10| |FORMAT.:{.11|

 |FORMATTER.:{.11| |FORMAT.:{.12| |FORMATTER.:{.12| |FORMAT.:{.13|

 |FORMATTER.:{.13| |FORMAT.:{.14| |FORMATTER.:{.14| |FORMAT.:{.15|

 |FORMATTER.:{.15| |FORMAT.:{.16| |FORMATTER.:{.16| |FORMAT.:{.17|

 |FORMATTER.:{.17| FORMAT.@{.1 FORMATTER.@{.1 FORMAT.@{.1A

 FORMATTER.@{.1A FORMAT.@{.2 FORMATTER.@{.2 FORMAT.@{.3 FORMATTER.@{.3

 FORMAT.@{.4 FORMATTER.@{.4 FORMAT.@{.5 FORMATTER.@{.5 FORMAT.@{.6

 FORMATTER.@{.6 FORMAT.@{.7 FORMATTER.@{.7 FORMAT.@{.8 FORMATTER.@{.8

 FORMAT.@{.9 FORMATTER.@{.9 FORMAT.@{.10 FORMATTER.@{.10 FORMAT.@{.11

 FORMATTER.@{.11 FORMAT.@{.12 FORMATTER.@{.12 FORMAT.@{.13

 FORMATTER.@{.13 |FORMAT.:@{.1| |FORMATTER.:@{.1| |FORMAT.:@{.2|

 |FORMATTER.:@{.2| |FORMAT.:@{.3| |FORMATTER.:@{.3| |FORMAT.:@{.4|

 |FORMATTER.:@{.4| |FORMAT.:@{.5| |FORMATTER.:@{.5| |FORMAT.:@.6|

 |FORMATTER.:@.6| |FORMAT.:@.7| |FORMATTER.:@.7| |FORMAT.:@.8|

 |FORMATTER.:@.8| |FORMAT.:@.9| |FORMATTER.:@.9| |FORMAT.:@.10|

 |FORMATTER.:@.10| FORMAT.{.ERROR.1 FORMAT.{.ERROR.2 FORMAT.{.ERROR.3

 FORMAT.{.ERROR.4 FORMAT.{.ERROR.5 |FORMAT.:{.ERROR.1|

 |FORMAT.:{.ERROR.2| |FORMAT.:{.ERROR.3| |FORMAT.:{.ERROR.4|

 |FORMAT.:{.ERROR.5| |FORMAT.:@{.ERROR.1| |FORMAT.:@{.ERROR.2|

 |FORMAT.:@{.ERROR.3| |FORMAT.:@{.ERROR.4| |FORMAT.:@{.ERROR.5|

 FORMAT.?.1 FORMATTER.?.1 FORMAT.?.2 FORMATTER.?.2 FORMAT.?.3

 FORMATTER.?.3 FORMAT.?.4 FORMATTER.?.4 FORMAT.?.5 FORMATTER.?.5

 FORMAT.@?.1 FORMATTER.@?.1 FORMAT.@?.2 FORMATTER.@?.2 FORMAT.@?.3

 FORMATTER.@?.3 FORMAT.@?.4 FORMATTER.@?.4 FORMAT.@?.5 FORMATTER.@?.5

 FORMAT.PAREN.1 FORMATTER.PAREN.1 FORMAT.PAREN.2 FORMATTER.PAREN.2

 FORMAT.PAREN.3 FORMATTER.PAREN.3 FORMAT.PAREN.4 FORMATTER.PAREN.4

 FORMAT.PAREN.5 FORMATTER.PAREN.5 FORMAT.PAREN.6 FORMATTER.PAREN.6

 FORMAT.PAREN.7 FORMATTER.PAREN.7 FORMAT.PAREN.8 FORMATTER.PAREN.8

 FORMAT.PAREN.9 FORMATTER.PAREN.9 FORMAT.PAREN.10 FORMATTER.PAREN.10

 FORMAT.PAREN.11 FORMATTER.PAREN.11 FORMAT.PAREN.12 FORMATTER.PAREN.12

 FORMAT.PAREN.13 FORMATTER.PAREN.13 FORMAT.PAREN.14 FORMATTER.PAREN.14

 FORMAT.PAREN.15 FORMATTER.PAREN.15 FORMAT.PAREN.16 FORMATTER.PAREN.16

 FORMAT.PAREN.17 FORMATTER.PAREN.17 FORMAT.PAREN.18 FORMATTER.PAREN.18

 FORMAT.PAREN.19 FORMATTER.PAREN.19 FORMAT.PAREN.20 FORMATTER.PAREN.20

 FORMAT.PAREN.21 FORMATTER.PAREN.21 FORMAT.PAREN.22 FORMATTER.PAREN.22

 FORMAT.PAREN.23 FORMATTER.PAREN.23 FORMAT.PAREN.24 FORMATTER.PAREN.24

 FORMAT.PAREN.25 FORMATTER.PAREN.25 FORMAT.P.1 FORMATTER.P.1 FORMAT.P.2

 FORMATTER.P.2 FORMAT.P.3 FORMATTER.P.3 FORMAT.P.4 FORMATTER.P.4

 FORMAT.P.5 FORMATTER.P.5 FORMAT.P.6 FORMATTER.P.6 FORMAT.P.7

 FORMATTER.P.7 FORMAT.P.8 FORMATTER.P.8 FORMAT.P.9 FORMATTER.P.9

 FORMAT.P.10 FORMATTER.P.10 FORMAT.P.11 FORMATTER.P.11 FORMAT.P.12

 FORMATTER.P.12 FORMAT.P.13 FORMATTER.P.13 FORMAT.P.14 FORMATTER.P.14

 FORMAT.P.15 FORMATTER.P.15 FORMAT.P.16 FORMATTER.P.16 FORMAT.P.17

 FORMATTER.P.17 FORMAT.P.18 FORMATTER.P.18 FORMAT.^.{.1 FORMATTER.^.{.1

 FORMAT.^.{.2 FORMATTER.^.{.2 FORMAT.^.{.3 FORMATTER.^.{.3 FORMAT.^.{.4

 FORMATTER.^.{.4 FORMAT.^.{.5 FORMATTER.^.{.5 FORMAT.^.{.6

 FORMATTER.^.{.6 FORMAT.^.{.7 FORMATTER.^.{.7 FORMAT.^.{.8

 FORMATTER.^.{.8 FORMAT.^.{.9 FORMATTER.^.{.9 FORMAT.^.{.10

 FORMATTER.^.{.10 FORMAT.^.{.11 FORMATTER.^.{.11 FORMAT.^.{.12

 FORMATTER.^.{.12 FORMAT.^.{.13 FORMATTER.^.{.13 FORMAT.^.{.14

 FORMATTER.^.{.14 FORMAT.^.{.15 FORMATTER.^.{.15 FORMAT.^.{.16

 FORMATTER.^.{.16 FORMAT.^.{.17 FORMATTER.^.{.17 FORMAT.^.{.18

 FORMATTER.^.{.18 FORMAT.^.{.19 FORMATTER.^.{.19 FORMAT.^.{.20

 FORMATTER.^.{.20 FORMAT.^.{.21 FORMATTER.^.{.21 FORMAT.^.{.22

 FORMATTER.^.{.22 FORMAT.^.{.23 FORMATTER.^.{.23 FORMAT.^.{.24

 FORMATTER.^.{.24 FORMAT.^.{.25 FORMATTER.^.{.25 FORMAT.^.{.26

 FORMATTER.^.{.26 FORMAT.^.{.27 FORMATTER.^.{.27 FORMAT.^.{.28

 FORMATTER.^.{.28 FORMAT.^.{.29 FORMATTER.^.{.29 FORMAT.^.{.30

 FORMATTER.^.{.30 FORMAT.^.{.31 FORMATTER.^.{.31 FORMAT.^.{.32

 FORMATTER.^.{.32 FORMAT.^.{.33 FORMATTER.^.{.33 |FORMAT.^.:{.1|

 |FORMATTER.^.:{.1| |FORMAT.^.:{.2| |FORMATTER.^.:{.2| |FORMAT.^.:{.3|

 |FORMATTER.^.:{.3| |FORMAT.^.:{.4| |FORMATTER.^.:{.4| |FORMAT.^.:{.5|

 |FORMATTER.^.:{.5| |FORMAT.^.:{.6| |FORMATTER.^.:{.6| |FORMAT.^.:{.7|

 |FORMATTER.^.:{.7| |FORMAT.^.:{.8| |FORMATTER.^.:{.8| |FORMAT.^.:{.9|

 |FORMATTER.^.:{.9| |FORMAT.^.:{.10| |FORMATTER.^.:{.10|

 |FORMAT.^.:{.11| |FORMATTER.^.:{.11| |FORMAT.^.:{.12|

 |FORMATTER.^.:{.12| |FORMAT.^.:{.13| |FORMATTER.^.:{.13|

 |FORMAT.^.:{.14| |FORMATTER.^.:{.14| |FORMAT.^.:{.15|

 |FORMATTER.^.:{.15| |FORMAT.^.:{.16| |FORMATTER.^.:{.16|

 |FORMAT.^.:{.17| |FORMATTER.^.:{.17| |FORMAT.^.:{.18|

 |FORMATTER.^.:{.18| |FORMAT.^.:{.19| |FORMATTER.^.:{.19|

 |FORMAT.^.:{.20| |FORMATTER.^.:{.20| |FORMAT.^.:{.21|

 |FORMATTER.^.:{.21| |FORMAT.^.:{.22| |FORMATTER.^.:{.22|

 |FORMAT.^.:{.23| |FORMATTER.^.:{.23| |FORMAT.^.:{.24|

 |FORMATTER.^.:{.24| |FORMAT.^.:{.25| |FORMATTER.^.:{.25|

 |FORMAT.^.:{.26| |FORMATTER.^.:{.26| |FORMAT.^.:{.27|

 |FORMATTER.^.:{.27| |FORMAT.^.:{.28| |FORMATTER.^.:{.28|

 |FORMAT.^.:{.29| |FORMATTER.^.:{.29| |FORMAT.^.:{.30|

 |FORMATTER.^.:{.30| |FORMAT.^.:{.31| |FORMATTER.^.:{.31|

 |FORMAT.^.:{.32| |FORMATTER.^.:{.32| |FORMAT.^.:{.33|

 |FORMATTER.^.:{.33| |FORMAT.^.:{.34| |FORMATTER.^.:{.34|

 |FORMAT.^.:{.35| |FORMATTER.^.:{.35| |FORMAT.^.:{.36|

 |FORMATTER.^.:{.36| |FORMAT.^.:{.37| |FORMATTER.^.:{.37|

 |FORMAT.^.:{.38| |FORMATTER.^.:{.38| |FORMAT.^.:{.39|

 |FORMATTER.^.:{.39| FORMAT.^.@{.1 FORMATTER.^.@{.1 FORMAT.^.@{.2

 FORMATTER.^.@{.2 FORMAT.^.@{.3 FORMATTER.^.@{.3 FORMAT.^.@{.4

 FORMATTER.^.@{.4 FORMAT.^.@{.5 FORMATTER.^.@{.5 FORMAT.^.@{.6

 FORMATTER.^.@{.6 FORMAT.^.@{.7 FORMATTER.^.@{.7 FORMAT.^.@{.8

 FORMATTER.^.@{.8 FORMAT.^.@{.9 FORMATTER.^.@{.9 FORMAT.^.@{.10

 FORMATTER.^.@{.10 FORMAT.^.@{.11 FORMATTER.^.@{.11 FORMAT.^.@{.12

 FORMATTER.^.@{.12 FORMAT.^.@{.13 FORMATTER.^.@{.13 FORMAT.^.@{.14

 FORMATTER.^.@{.14 FORMAT.^.@{.15 FORMATTER.^.@{.15 FORMAT.^.@{.16

 FORMATTER.^.@{.16 FORMAT.^.@{.17 FORMATTER.^.@{.17 FORMAT.^.@{.18

 FORMATTER.^.@{.18 FORMAT.^.@{.19 FORMATTER.^.@{.19 FORMAT.^.@{.20

 FORMATTER.^.@{.20 FORMAT.^.@{.21 FORMATTER.^.@{.21 FORMAT.^.@{.22

 FORMATTER.^.@{.22 FORMAT.^.@{.23 FORMATTER.^.@{.23 FORMAT.^.@{.24

 FORMATTER.^.@{.24 FORMAT.^.@{.25 FORMATTER.^.@{.25 FORMAT.^.@{.26

 FORMATTER.^.@{.26 FORMAT.^.@{.27 FORMATTER.^.@{.27 FORMAT.^.@{.28

 FORMATTER.^.@{.28 FORMAT.^.@{.29 FORMATTER.^.@{.29 FORMAT.^.@{.30

 FORMATTER.^.@{.30 FORMAT.^.@{.31 FORMATTER.^.@{.31 FORMAT.^.@{.32

 FORMATTER.^.@{.32 FORMAT.^.@{.33 FORMATTER.^.@{.33 |FORMAT.^.:@{.1|

 |FORMATTER.^.:@{.1| |FORMAT.^.:@{.2| |FORMATTER.^.:@{.2|

 |FORMAT.^.:@{.3| |FORMATTER.^.:@{.3| |FORMAT.^.:@{.4|

 |FORMATTER.^.:@{.4| |FORMAT.^.:@{.5| |FORMATTER.^.:@{.5|

 |FORMAT.^.:@{.6| |FORMATTER.^.:@{.6| |FORMAT.^.:@{.7|

 |FORMATTER.^.:@{.7| |FORMAT.^.:@{.8| |FORMATTER.^.:@{.8|

 |FORMAT.^.:@{.9| |FORMATTER.^.:@{.9| |FORMAT.^.:@{.10|

 |FORMATTER.^.:@{.10| |FORMAT.^.:@{.11| |FORMATTER.^.:@{.11|

 |FORMAT.^.:@{.12| |FORMATTER.^.:@{.12| |FORMAT.^.:@{.13|

 |FORMATTER.^.:@{.13| |FORMAT.^.:@{.14| |FORMATTER.^.:@{.14|

 |FORMAT.^.:@{.15| |FORMATTER.^.:@{.15| |FORMAT.^.:@{.16|

 |FORMATTER.^.:@{.16| |FORMAT.^.:@{.17| |FORMATTER.^.:@{.17|

 |FORMAT.^.:@{.18| |FORMATTER.^.:@{.18| |FORMAT.^.:@{.19|

 |FORMATTER.^.:@{.19| |FORMAT.^.:@{.20| |FORMATTER.^.:@{.20|

 |FORMAT.^.:@{.21| |FORMATTER.^.:@{.21| |FORMAT.^.:@{.22|

 |FORMATTER.^.:@{.22| |FORMAT.^.:@{.23| |FORMATTER.^.:@{.23|

 |FORMAT.^.:@{.24| |FORMATTER.^.:@{.24| |FORMAT.^.:@{.25|

 |FORMATTER.^.:@{.25| |FORMAT.^.:@{.26| |FORMATTER.^.:@{.26|

 |FORMAT.^.:@{.27| |FORMATTER.^.:@{.27| |FORMAT.^.:@{.28|

 |FORMATTER.^.:@{.28| |FORMAT.^.:@{.29| |FORMATTER.^.:@{.29|

 |FORMAT.^.:@{.30| |FORMATTER.^.:@{.30| |FORMAT.^.:@{.31|

 |FORMATTER.^.:@{.31| |FORMAT.^.:@{.32| |FORMATTER.^.:@{.32|

 |FORMAT.^.:@{.33| |FORMATTER.^.:@{.33| |FORMAT.^.:@{.34|

 |FORMATTER.^.:@{.34| |FORMAT.^.:@{.35| |FORMATTER.^.:@{.35|

 |FORMAT.^.:@{.36| |FORMATTER.^.:@{.36| |FORMAT.^.:@{.37|

 |FORMATTER.^.:@{.37| |FORMAT.^.:@{.38| |FORMATTER.^.:@{.38|

 |FORMAT.^.:@{.39| |FORMATTER.^.:@{.39| |FORMAT.:^.:{.1|

 |FORMATTER.:^.:{.1| |FORMAT.:^.:{.2| |FORMATTER.:^.:{.2|

 |FORMAT.:^.:{.3| |FORMATTER.:^.:{.3| |FORMAT.:^.:{.4|

 |FORMATTER.:^.:{.4| |FORMAT.:^.:{.5| |FORMATTER.:^.:{.5|

 |FORMAT.:^.:{.6| |FORMATTER.:^.:{.6| |FORMAT.:^.:{.7|

 |FORMATTER.:^.:{.7| |FORMAT.:^.:{.8| |FORMATTER.:^.:{.8|

 |FORMAT.:^.:{.9| |FORMATTER.:^.:{.9| |FORMAT.:^.:{.10|

 |FORMATTER.:^.:{.10| |FORMAT.:^.:{.11| |FORMATTER.:^.:{.11|

 |FORMAT.:^.:{.12| |FORMATTER.:^.:{.12| |FORMAT.:^.:{.13|

 |FORMATTER.:^.:{.13| |FORMAT.:^.:{.14| |FORMATTER.:^.:{.14|

 |FORMAT.:^.:{.15| |FORMATTER.:^.:{.15| |FORMAT.:^.:{.16|

 |FORMATTER.:^.:{.16| |FORMAT.:^.:{.17| |FORMATTER.:^.:{.17|

 |FORMAT.:^.:{.18| |FORMATTER.:^.:{.18| |FORMAT.:^.:{.19|

 |FORMATTER.:^.:{.19| |FORMAT.:^.:{.20| |FORMATTER.:^.:{.20|

 |FORMAT.:^.:{.21| |FORMATTER.:^.:{.21| |FORMAT.:^.:{.22|

 |FORMATTER.:^.:{.22| |FORMAT.:^.:{.23| |FORMATTER.:^.:{.23|

 |FORMAT.:^.:{.24| |FORMATTER.:^.:{.24| |FORMAT.:^.:{.25|

 |FORMATTER.:^.:{.25| |FORMAT.:^.:{.26| |FORMATTER.:^.:{.26|

 |FORMAT.:^.:{.27| |FORMATTER.:^.:{.27| |FORMAT.:^.:{.28|

 |FORMATTER.:^.:{.28| |FORMAT.:^.:{.29| |FORMATTER.:^.:{.29|

 |FORMAT.:^.:{.30| |FORMATTER.:^.:{.30| |FORMAT.:^.:{.31|

 |FORMATTER.:^.:{.31| |FORMAT.:^.:{.32| |FORMATTER.:^.:{.32|

 |FORMAT.:^.:{.33| |FORMATTER.:^.:{.33| |FORMAT.:^.:{.34|

 |FORMATTER.:^.:{.34| |FORMAT.:^.:{.35| |FORMATTER.:^.:{.35|

 |FORMAT.:^.:{.36| |FORMATTER.:^.:{.36| |FORMAT.:^.:{.37|

 |FORMATTER.:^.:{.37| |FORMAT.:^.:{.38| |FORMATTER.:^.:{.38|

 |FORMAT.:^.:{.39| |FORMATTER.:^.:{.39| |FORMAT.:^.:@{.1|

 |FORMATTER.:^.:@{.1| |FORMAT.:^.:@{.2| |FORMATTER.:^.:@{.2|

 |FORMAT.:^.:@{.3| |FORMATTER.:^.:@{.3| |FORMAT.:^.:@{.4|

 |FORMATTER.:^.:@{.4| |FORMAT.:^.:@{.5| |FORMATTER.:^.:@{.5|

 |FORMAT.:^.:@{.6| |FORMATTER.:^.:@{.6| |FORMAT.:^.:@{.7|

 |FORMATTER.:^.:@{.7| |FORMAT.:^.:@{.8| |FORMATTER.:^.:@{.8|

 |FORMAT.:^.:@{.9| |FORMATTER.:^.:@{.9| |FORMAT.:^.:@{.10|

 |FORMATTER.:^.:@{.10| |FORMAT.:^.:@{.11| |FORMATTER.:^.:@{.11|

 |FORMAT.:^.:@{.12| |FORMATTER.:^.:@{.12| |FORMAT.:^.:@{.13|

 |FORMATTER.:^.:@{.13| |FORMAT.:^.:@{.14| |FORMATTER.:^.:@{.14|

 |FORMAT.:^.:@{.15| |FORMATTER.:^.:@{.15| |FORMAT.:^.:@{.16|

 |FORMATTER.:^.:@{.16| |FORMAT.:^.:@{.17| |FORMATTER.:^.:@{.17|

 |FORMAT.:^.:@{.18| |FORMATTER.:^.:@{.18| |FORMAT.:^.:@{.19|

 |FORMATTER.:^.:@{.19| |FORMAT.:^.:@{.20| |FORMATTER.:^.:@{.20|

 |FORMAT.:^.:@{.21| |FORMATTER.:^.:@{.21| |FORMAT.:^.:@{.22|

 |FORMATTER.:^.:@{.22| |FORMAT.:^.:@{.23| |FORMATTER.:^.:@{.23|

 |FORMAT.:^.:@{.24| |FORMATTER.:^.:@{.24| |FORMAT.:^.:@{.25|

 |FORMATTER.:^.:@{.25| |FORMAT.:^.:@{.26| |FORMATTER.:^.:@{.26|

 |FORMAT.:^.:@{.27| |FORMATTER.:^.:@{.27| |FORMAT.:^.:@{.28|

 |FORMATTER.:^.:@{.28| |FORMAT.:^.:@{.29| |FORMATTER.:^.:@{.29|

 |FORMAT.:^.:@{.30| |FORMATTER.:^.:@{.30| |FORMAT.:^.:@{.31|

 |FORMATTER.:^.:@{.31| |FORMAT.:^.:@{.32| |FORMATTER.:^.:@{.32|

 |FORMAT.:^.:@{.33| |FORMATTER.:^.:@{.33| |FORMAT.:^.:@{.34|

 |FORMATTER.:^.:@{.34| |FORMAT.:^.:@{.35| |FORMATTER.:^.:@{.35|

 |FORMAT.:^.:@{.36| |FORMATTER.:^.:@{.36| |FORMAT.:^.:@{.37|

 |FORMATTER.:^.:@{.37| |FORMAT.:^.:@{.38| |FORMATTER.:^.:@{.38|

 |FORMAT.:^.:@{.39| |FORMATTER.:^.:@{.39| FORMAT.^.?.1 FORMATTER.^.?.1

 FORMAT.^.?.2 FORMATTER.^.?.2 FORMAT.^.?.3 FORMATTER.^.?.3 FORMAT.^.?.4

 FORMATTER.^.?.4 FORMAT.^.@?.1 FORMATTER.^.@?.1 FORMAT.^.@?.2

 FORMATTER.^.@?.2 FORMAT.^.[.1 FORMATTER.^.[.1 FORMAT.^.[.2

 FORMATTER.^.[.2 FORMAT.^.[.3 FORMATTER.^.[.3 |FORMAT.^.(.1|

 |FORMATTER.^.(.1| |FORMAT.^.:(.1| |FORMATTER.^.:(.1| |FORMAT.^.@(.1|

 |FORMATTER.^.@(.1| |FORMAT.^.@:(.1| |FORMATTER.^.@:(.1|

 FORMAT.NEWLINE.1 FORMATTER.NEWLINE.1 FORMAT.NEWLINE.2

 FORMATTER.NEWLINE.2 FORMAT.NEWLINE.3 FORMATTER.NEWLINE.3 READ-SYMBOL.1

 READ-SYMBOL.2 READ-SYMBOL.3 READ-SYMBOL.4 READ-SYMBOL.5 READ-SYMBOL.6

 READ-SYMBOL.7 READ-SYMBOL.9 READ-SYMBOL.9A READ-SYMBOL.9B

 READ-SYMBOL.10 READ-SYMBOL.11 READ-SYMBOL.12 READ-SYMBOL.13

 READ-SYMBOL.14 READ-SYMBOL.15 READ-SYMBOL.16 READ-SYMBOL.17

 READ-SYMBOL.18 READ-SYMBOL.19 READ-SYMBOL.20 READ-SYMBOL.21

 READ-SYMBOL.22 READ-SYMBOL.23 READ-SYMBOL.24 READ-SYMBOL.25

 READ-FLOAT.1 WITH-STANDARD-IO-SYNTAX.1 WITH-STANDARD-IO-SYNTAX.2

 WITH-STANDARD-IO-SYNTAX.3 WITH-STANDARD-IO-SYNTAX.4

 WITH-STANDARD-IO-SYNTAX.5 WITH-STANDARD-IO-SYNTAX.6

 WITH-STANDARD-IO-SYNTAX.7 WITH-STANDARD-IO-SYNTAX.8

 WITH-STANDARD-IO-SYNTAX.9 WITH-STANDARD-IO-SYNTAX.10

 WITH-STANDARD-IO-SYNTAX.11 WITH-STANDARD-IO-SYNTAX.12

 WITH-STANDARD-IO-SYNTAX.13 WITH-STANDARD-IO-SYNTAX.14

 WITH-STANDARD-IO-SYNTAX.15 WITH-STANDARD-IO-SYNTAX.16

 WITH-STANDARD-IO-SYNTAX.17 WITH-STANDARD-IO-SYNTAX.18

 WITH-STANDARD-IO-SYNTAX.19 WITH-STANDARD-IO-SYNTAX.20

 WITH-STANDARD-IO-SYNTAX.21 WITH-STANDARD-IO-SYNTAX.22 COPY-READTABLE.1

 COPY-READTABLE.2 COPY-READTABLE.3 COPY-READTABLE.4 COPY-READTABLE.5

 COPY-READTABLE.6 COPY-READTABLE.7 COPY-READTABLE.ERROR.1 READ.1 READ.2

 READ.3 READ.4 READ.5 READ.6 READ.7 READ.8 READ.9 READ.10 READ.11

 READ.12 READ.13 READ.14 READ.15 READ.16 READ.17 READ.18 READ.19

 READ.ERROR.1 READ.ERROR.2 READ.ERROR.3 READ.ERROR.4 READ.ERROR.5

 READ.ERROR.6 READ.ERROR.7 READ.ERROR.8 READ-PRESERVING-WHITESPACE.1

 READ-PRESERVING-WHITESPACE.2 READ-PRESERVING-WHITESPACE.3

 READ-PRESERVING-WHITESPACE.4 READ-PRESERVING-WHITESPACE.5

 READ-PRESERVING-WHITESPACE.6 READ-PRESERVING-WHITESPACE.7

 READ-PRESERVING-WHITESPACE.8 READ-PRESERVING-WHITESPACE.9

 READ-PRESERVING-WHITESPACE.10 READ-PRESERVING-WHITESPACE.11

 READ-PRESERVING-WHITESPACE.12 READ-PRESERVING-WHITESPACE.13

 READ-PRESERVING-WHITESPACE.14 READ-PRESERVING-WHITESPACE.15

 READ-PRESERVING-WHITESPACE.16 READ-PRESERVING-WHITESPACE.17

 READ-PRESERVING-WHITESPACE.18 READ-PRESERVING-WHITESPACE.19

 READ-PRESERVING-WHITESPACE.ERROR.1 READ-PRESERVING-WHITESPACE.ERROR.2

 READ-PRESERVING-WHITESPACE.ERROR.3 READ-PRESERVING-WHITESPACE.ERROR.4

 READ-PRESERVING-WHITESPACE.ERROR.5 READ-PRESERVING-WHITESPACE.ERROR.6

 READ-PRESERVING-WHITESPACE.ERROR.7 READ-PRESERVING-WHITESPACE.ERROR.8

 READ-DELIMITED-LIST.1 READ-DELIMITED-LIST.2 READ-DELIMITED-LIST.3

 READ-DELIMITED-LIST.4 READ-DELIMITED-LIST.5 READ-DELIMITED-LIST.6

 READ-DELIMITED-LIST.ERROR.1 READ-DELIMITED-LIST.ERROR.2

 READ-FROM-STRING.1 READ-FROM-STRING.2 READ-FROM-STRING.3

 READ-FROM-STRING.4 READ-FROM-STRING.5 READ-FROM-STRING.6

 READ-FROM-STRING.7 READ-FROM-STRING.8 READ-FROM-STRING.9

 READ-FROM-STRING.10 READ-FROM-STRING.11 READ-FROM-STRING.12

 READ-FROM-STRING.13 READ-FROM-STRING.14 READ-FROM-STRING.15

 READ-FROM-STRING.16 READ-FROM-STRING.17 READ-FROM-STRING.ERROR.1

 READ-FROM-STRING.ERROR.2 READ-FROM-STRING.ERROR.3

 READ-FROM-STRING.ERROR.4 READ-FROM-STRING.ERROR.5

 READ-FROM-STRING.ERROR.6 READ-FROM-STRING.ERROR.7

 READ-FROM-STRING.ERROR.8 READ-FROM-STRING.ERROR.9

 READ-FROM-STRING.ERROR.10 READ-FROM-STRING.ERROR.11

 READ-FROM-STRING.ERROR.12 READ-FROM-STRING.ERROR.13 READTABLE-CASE.1

 READTABLE-CASE.2 READTABLE-CASE.3 READTABLE-CASE.4 READTABLE-CASE.5

 READTABLE-CASE.6 READTABLE-CASE.7 READTABLE-CASE.ERROR.1

 READTABLE-CASE.ERROR.2 READTABLE-CASE.ERROR.3 READTABLE-CASE.ERROR.4

 READTABLE-CASE.ERROR.5 READTABLEP.1 READTABLEP.2 READTABLEP.3

 READTABLEP.4 READTABLEP.ERROR.1 READTABLEP.ERROR.2 READTABLEP.ERROR.3

 GET-MACRO-CHARACTER.1 GET-MACRO-CHARACTER.2 GET-MACRO-CHARACTER.3

 GET-MACRO-CHARACTER.4 GET-MACRO-CHARACTER.5 GET-MACRO-CHARACTER.6

 GET-MACRO-CHARACTER.7 GET-MACRO-CHARACTER.ERROR.1

 GET-MACRO-CHARACTER.ERROR.2 SET-MACRO-CHARACTER.1 SET-MACRO-CHARACTER.2

 SET-MACRO-CHARACTER.3 READ-SUPPRESS.1 READ-SUPPRESS.2 READ-SUPPRESS.3

 READ-SUPPRESS.4 READ-SUPPRESS.5 READ-SUPPRESS.7 READ-SUPPRESS.8

 READ-SUPPRESS.9 READ-SUPPRESS.10 READ-SUPPRESS.11 READ-SUPPRESS.12

 READ-SUPPRESS.13 READ-SUPPRESS.14 READ-SUPPRESS.15 READ-SUPPRESS.16

 READ-SUPPRESS.SHARP-SLASH.1 READ-SUPPRESS.SHARP-SLASH.2

 READ-SUPPRESS.SHARP-SLASH.3 READ-SUPPRESS.SHARP-SLASH.4

 READ-SUPPRESS.SHARP-SLASH.5 READ-SUPPRESS.SHARP-SLASH.6

 READ-SUPPRESS.SHARP-QUOTE.1 READ-SUPPRESS.SHARP-QUOTE.2

 READ-SUPPRESS.SHARP-QUOTE.3 READ-SUPPRESS.SHARP-QUOTE.5

 READ-SUPPRESS.SHARP-QUOTE.6 READ-SUPPRESS.SHARP-QUOTE.7

 READ-SUPPRESS.SHARP-QUOTE.8 READ-SUPPRESS.SHARP-LEFT-PAREN.1

 READ-SUPPRESS.SHARP-LEFT-PAREN.2 READ-SUPPRESS.SHARP-LEFT-PAREN.3

 READ-SUPPRESS.SHARP-LEFT-PAREN.4 READ-SUPPRESS.SHARP-LEFT-PAREN.5

 READ-SUPPRESS.SHARP-LEFT-PAREN.6 READ-SUPPRESS.SHARP-LEFT-PAREN.7

 READ-SUPPRESS.SHARP-LEFT-PAREN.8 READ-SUPPRESS.SHARP-LEFT-PAREN.9

 READ-SUPPRESS.SHARP-LEFT-PAREN.10 READ-SUPPRESS.SHARP-LEFT-PAREN.11

 READ-SUPPRESS.SHARP-LEFT-PAREN.12 READ-SUPPRESS.SHARP-ASTERISK.1

 READ-SUPPRESS.SHARP-ASTERISK.2 READ-SUPPRESS.SHARP-ASTERISK.3

 READ-SUPPRESS.SHARP-ASTERISK.4 READ-SUPPRESS.SHARP-ASTERISK.5

 READ-SUPPRESS.SHARP-ASTERISK.6 READ-SUPPRESS.SHARP-ASTERISK.7

 READ-SUPPRESS.SHARP-ASTERISK.8 READ-SUPPRESS.SHARP-ASTERISK.9

 READ-SUPPRESS.SHARP-ASTERISK.10 READ-SUPPRESS.SHARP-ASTERISK.11

 READ-SUPPRESS.SHARP-ASTERISK.12 READ-SUPPRESS.SHARP-ASTERISK.13

 READ-SUPPRESS.SHARP-ASTERISK.14 READ-SUPPRESS.SHARP-COLON.1

 READ-SUPPRESS.SHARP-COLON.2 READ-SUPPRESS.SHARP-COLON.3

 READ-SUPPRESS.SHARP-COLON.4 READ-SUPPRESS.SHARP-COLON.5

 READ-SUPPRESS.SHARP-COLON.6 READ-SUPPRESS.SHARP-COLON.7

 READ-SUPPRESS.SHARP-COLON.8 READ-SUPPRESS.SHARP-COLON.9

 READ-SUPPRESS.SHARP-DOT.1 READ-SUPPRESS.SHARP-DOT.2

 READ-SUPPRESS.SHARP-DOT.3 READ-SUPPRESS.SHARP-DOT.4

 READ-SUPPRESS.SHARP-DOT.5 READ-SUPPRESS.SHARP-DOT.6

 READ-SUPPRESS.SHARP-B.1 READ-SUPPRESS.SHARP-B.2 READ-SUPPRESS.SHARP-B.3

 READ-SUPPRESS.SHARP-B.4 READ-SUPPRESS.SHARP-B.5 READ-SUPPRESS.SHARP-B.6

 READ-SUPPRESS.SHARP-B.7 READ-SUPPRESS.SHARP-B.8 READ-SUPPRESS.SHARP-B.9

 READ-SUPPRESS.SHARP-B.10 READ-SUPPRESS.SHARP-O.1

 READ-SUPPRESS.SHARP-O.2 READ-SUPPRESS.SHARP-O.3 READ-SUPPRESS.SHARP-O.4

 READ-SUPPRESS.SHARP-O.5 READ-SUPPRESS.SHARP-O.6 READ-SUPPRESS.SHARP-O.7

 READ-SUPPRESS.SHARP-O.8 READ-SUPPRESS.SHARP-O.9

 READ-SUPPRESS.SHARP-O.10 READ-SUPPRESS.SHARP-C.1

 READ-SUPPRESS.SHARP-C.2 READ-SUPPRESS.SHARP-C.3 READ-SUPPRESS.SHARP-C.4

 READ-SUPPRESS.SHARP-C.5 READ-SUPPRESS.SHARP-C.6 READ-SUPPRESS.SHARP-C.7

 READ-SUPPRESS.SHARP-C.8 READ-SUPPRESS.SHARP-C.9

 READ-SUPPRESS.SHARP-C.10 READ-SUPPRESS.SHARP-C.11

 READ-SUPPRESS.SHARP-C.12 READ-SUPPRESS.SHARP-C.13

 READ-SUPPRESS.SHARP-C.14 READ-SUPPRESS.SHARP-C.15

 READ-SUPPRESS.SHARP-X.1 READ-SUPPRESS.SHARP-X.2 READ-SUPPRESS.SHARP-X.3

 READ-SUPPRESS.SHARP-X.4 READ-SUPPRESS.SHARP-X.5 READ-SUPPRESS.SHARP-X.6

 READ-SUPPRESS.SHARP-X.7 READ-SUPPRESS.SHARP-X.8 READ-SUPPRESS.SHARP-X.9

 READ-SUPPRESS.SHARP-X.10 READ-SUPPRESS.SHARP-R.1

 READ-SUPPRESS.SHARP-R.2 READ-SUPPRESS.SHARP-R.3 READ-SUPPRESS.SHARP-R.4

 READ-SUPPRESS.SHARP-R.5 READ-SUPPRESS.SHARP-R.6 READ-SUPPRESS.SHARP-R.7

 READ-SUPPRESS.SHARP-R.8 READ-SUPPRESS.SHARP-R.9

 READ-SUPPRESS.SHARP-R.10 READ-SUPPRESS.SHARP-A.1

 READ-SUPPRESS.SHARP-A.2 READ-SUPPRESS.SHARP-A.3 READ-SUPPRESS.SHARP-A.4

 READ-SUPPRESS.SHARP-A.5 READ-SUPPRESS.SHARP-A.6 READ-SUPPRESS.SHARP-A.7

 READ-SUPPRESS.SHARP-A.8 READ-SUPPRESS.SHARP-A.9 READ-SUPPRESS.SHARP-S.1

 READ-SUPPRESS.SHARP-S.2 READ-SUPPRESS.SHARP-S.3 READ-SUPPRESS.SHARP-S.4

 READ-SUPPRESS.SHARP-S.5 READ-SUPPRESS.SHARP-S.6 READ-SUPPRESS.SHARP-S.7

 READ-SUPPRESS.SHARP-S.8 READ-SUPPRESS.SHARP-S.9 READ-SUPPRESS.SHARP-P.1

 READ-SUPPRESS.SHARP-P.2 READ-SUPPRESS.SHARP-P.3 READ-SUPPRESS.SHARP-P.4

 READ-SUPPRESS.SHARP-P.5 READ-SUPPRESS.SHARP-P.6 READ-SUPPRESS.SHARP-P.7

 READ-SUPPRESS.SHARP-EQUAL.1 READ-SUPPRESS.SHARP-EQUAL.2

 READ-SUPPRESS.SHARP-EQUAL.3 READ-SUPPRESS.SHARP-EQUAL.4

 READ-SUPPRESS.SHARP-SHARP.1 READ-SUPPRESS.SHARP-SHARP.2

 READ-SUPPRESS.SHARP-SHARP.3 READ-SUPPRESS.SHARP-SHARP.4

 READ-SUPPRESS.ERROR.1 READ-SUPPRESS.ERROR.2 READ-SUPPRESS.ERROR.3

 READ-SUPPRESS.ERROR.4 SET-SYNTAX-FROM-CHAR-TRAIT-X-REVERSE_SOLIDUS

 SET-SYNTAX-FROM-CHAR-TRAIT-X-VERTICAL_LINE

 SET-SYNTAX-FROM-CHAR-TRAIT-X-EXCLAMATION_MARK

 SET-SYNTAX-FROM-CHAR-TRAIT-X-QUOTATION_MARK

 SET-SYNTAX-FROM-CHAR-TRAIT-X-NUMBER_SIGN

 SET-SYNTAX-FROM-CHAR-TRAIT-X-DOLLAR_SIGN

 SET-SYNTAX-FROM-CHAR-TRAIT-X-PERCENT_SIGN

 SET-SYNTAX-FROM-CHAR-TRAIT-X-AMPERSAND

 SET-SYNTAX-FROM-CHAR-TRAIT-X-APOSTROPHE

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LEFT_PARENTHESIS

 SET-SYNTAX-FROM-CHAR-TRAIT-X-RIGHT_PARENTHESIS

 SET-SYNTAX-FROM-CHAR-TRAIT-X-ASTERISK

 SET-SYNTAX-FROM-CHAR-TRAIT-X-COMMA

 SET-SYNTAX-FROM-CHAR-TRAIT-X-SEMICOLON

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LESS-THAN_SIGN

 SET-SYNTAX-FROM-CHAR-TRAIT-X-EQUALS_SIGN

 SET-SYNTAX-FROM-CHAR-TRAIT-X-GREATER-THAN_SIGN

 SET-SYNTAX-FROM-CHAR-TRAIT-X-QUESTION_MARK

 SET-SYNTAX-FROM-CHAR-TRAIT-X-COMMERCIAL_AT

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LEFT_SQUARE_BRACKET

 SET-SYNTAX-FROM-CHAR-TRAIT-X-RIGHT_SQUARE_BRACKET

 SET-SYNTAX-FROM-CHAR-TRAIT-X-CIRCUMFLEX_ACCENT

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LOW_LINE

 SET-SYNTAX-FROM-CHAR-TRAIT-X-GRAVE_ACCENT

 SET-SYNTAX-FROM-CHAR-TRAIT-X-TILDE

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LEFT_CURLY_BRACKET

 SET-SYNTAX-FROM-CHAR-TRAIT-X-RIGHT_CURLY_BRACKET

 SET-SYNTAX-FROM-CHAR-TRAIT-X-PLUS_SIGN

 SET-SYNTAX-FROM-CHAR-TRAIT-X-HYPHEN-MINUS

 SET-SYNTAX-FROM-CHAR-TRAIT-X-SOLIDUS

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_A

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_B

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_C

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_D

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_E

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_F

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_G

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_H

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_I

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_J

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_K

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_L

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_M

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_N

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_O

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_P

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_Q

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_R

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_S

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_T

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_U

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_V

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_W

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_X

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_Y

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_SMALL_LETTER_Z

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_A

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_B

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_C

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_D

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_E

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_F

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_G

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_H

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_I

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_J

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_K

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_L

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_M

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_N

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_O

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_P

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_Q

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_R

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_S

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_T

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_U

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_V

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_W

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_X

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_Y

 SET-SYNTAX-FROM-CHAR-TRAIT-X-LATIN_CAPITAL_LETTER_Z

 |SET-SYNTAX-FROM-CHAR-TRAIT-X-BACKSPACE|

 |SET-SYNTAX-FROM-CHAR-TRAIT-X-TAB|

 |SET-SYNTAX-FROM-CHAR-TRAIT-X-NEWLINE|

 |SET-SYNTAX-FROM-CHAR-TRAIT-X-PAGE|

 |SET-SYNTAX-FROM-CHAR-TRAIT-X-RETURN|

 |SET-SYNTAX-FROM-CHAR-TRAIT-X-SPACE|

 |SET-SYNTAX-FROM-CHAR-TRAIT-X-RUBOUT|

 SET-SYNTAX-FROM-CHAR.SINGLE-ESCAPE.1

 SET-SYNTAX-FROM-CHAR.SINGLE-ESCAPE.2

 SET-SYNTAX-FROM-CHAR.MULTIPLE-ESCAPE SET-SYNTAX-FROM-CHAR.SEMICOLON

 SET-SYNTAX-FROM-CHAR.LEFT-PAREN SET-SYNTAX-FROM-CHAR.RIGHT-PAREN

 SET-SYNTAX-FROM-CHAR.SINGLE-QUOTE SET-SYNTAX-FROM-CHAR.DOUBLE-QUOTE

 SET-SYNTAX-FROM-CHAR.BACKQUOTE SET-SYNTAX-FROM-CHAR.COMMA

 SET-SYNTAX-FROM-CHAR.SHARP.1 SET-SYNTAX-FROM-CHAR.SHARP.2

 MAKE-DISPATCH-MACRO-CHARACTER.1 MAKE-DISPATCH-MACRO-CHARACTER.2

 MAKE-DISPATCH-MACRO-CHARACTER.3 MAKE-DISPATCH-MACRO-CHARACTER.4

 MAKE-DISPATCH-MACRO-CHARACTER.ERROR.1

 MAKE-DISPATCH-MACRO-CHARACTER.ERROR.2 GET-DISPATCH-MACRO-CHARACTER.1

 SYNTAX.WHITESPACE.1 SYNTAX.CONSTITUENT.1 SYNTAX.BACKSPACE.INVALID

 SYNTAX.RUBOUT.INVALID SYNTAX.DIGITS.ALPHABETIC.1 SYNTAX.ESCAPED.1

 SYNTAX.ESCAPED.2 SYNTAX.ESCAPED.3 SYNTAX.ESCAPED.4 SYNTAX.ESCAPED.5

 SYNTAX.ESCAPED.6 SYNTAX.ESCAPE.WHITESPACE.1 SYNTAX.ESCAPE.WHITESPACE.2

 SYNTAX.SHARP-BACKSLASH.1 SYNTAX.SHARP-BACKSLASH.2

 SYNTAX.SHARP-BACKSLASH.3 SYNTAX.SHARP-BACKSLASH.4

 SYNTAX.SHARP-BACKSLASH.5 SYNTAX.SHARP-BACKSLASH.6

 SYNTAX.SHARP-BACKSLASH.7 SYNTAX.SHARP-QUOTE.1 SYNTAX.SHARP-QUOTE.2

 SYNTAX.SHARP-QUOTE.3 SYNTAX.SHARP-QUOTE.ERROR.1

 SYNTAX.SHARP-QUOTE.ERROR.2 SYNTAX.SHARP-LEFT-PAREN.1

 SYNTAX.SHARP-LEFT-PAREN.2 SYNTAX.SHARP-LEFT-PAREN.3

 SYNTAX.SHARP-LEFT-PAREN.4 SYNTAX.SHARP-LEFT-PAREN.5

 SYNTAX.SHARP-LEFT-PAREN.6 SYNTAX.SHARP-LEFT-PAREN.7

 SYNTAX.SHARP-LEFT-PAREN.8 SYNTAX.SHARP-LEFT-PAREN.9

 SYNTAX.SHARP-LEFT-PAREN.ERROR.1 SYNTAX.SHARP-LEFT-PAREN.ERROR.2

 SYNTAX.SHARP-ASTERISK.1 SYNTAX.SHARP-ASTERISK.2 SYNTAX.SHARP-ASTERISK.3

 SYNTAX.SHARP-ASTERISK.4 SYNTAX.SHARP-ASTERISK.5 SYNTAX.SHARP-ASTERISK.6

 SYNTAX.SHARP-ASTERISK.7 SYNTAX.SHARP-ASTERISK.8 SYNTAX.SHARP-ASTERISK.9

 SYNTAX.SHARP-ASTERISK.10 SYNTAX.SHARP-ASTERISK.11

 SYNTAX.SHARP-ASTERISK.12 SYNTAX.SHARP-ASTERISK.13

 SYNTAX.SHARP-ASTERISK.ERROR.1 SYNTAX.SHARP-ASTERISK.ERROR.2

 SYNTAX.SHARP-ASTERISK.ERROR.3 SYNTAX.SHARP-COLON.3 SYNTAX.SHARP-COLON.4

 SYNTAX.SHARP-COLON.5 SYNTAX.SHARP-COLON.6 SYNTAX.SHARP-COLON.7

 SYNTAX.SHARP-DOT.1 SYNTAX.SHARP-DOT.2 SYNTAX.SHARP-DOT.ERROR.1

 SYNTAX.SHARP-DOT.ERROR.2 SYNTAX.SHARP-DOT.ERROR.3 SYNTAX.SHARP-B.1

 SYNTAX.SHARP-B.2 SYNTAX.SHARP-B.3 SYNTAX.SHARP-B.4 SYNTAX.SHARP-B.5

 SYNTAX.SHARP-B.6 SYNTAX.SHARP-B.7 SYNTAX.SHARP-B.8 SYNTAX.SHARP-B.9

 SYNTAX.SHARP-B.10 SYNTAX.SHARP-O.1 SYNTAX.SHARP-O.2 SYNTAX.SHARP-O.3

 SYNTAX.SHARP-O.4 SYNTAX.SHARP-O.5 SYNTAX.SHARP-O.6 SYNTAX.SHARP-O.7

 SYNTAX.SHARP-O.8 SYNTAX.SHARP-O.9 SYNTAX.SHARP-O.10 SYNTAX.SHARP-X.1

 SYNTAX.SHARP-X.2 SYNTAX.SHARP-X.3 SYNTAX.SHARP-X.4 SYNTAX.SHARP-X.5

 SYNTAX.SHARP-X.6 SYNTAX.SHARP-X.7 SYNTAX.SHARP-X.8 SYNTAX.SHARP-X.9

 SYNTAX.SHARP-X.10 SYNTAX.SHARP-X.11 SYNTAX.SHARP-X.12 SYNTAX.SHARP-X.13

 SYNTAX.SHARP-X.14 SYNTAX.SHARP-X.15 SYNTAX.SHARP-R.1 SYNTAX.SHARP-R.2

 SYNTAX.SHARP-R.3 SYNTAX.SHARP-R.4 SYNTAX.SHARP-R.5 SYNTAX.SHARP-R.6

 SYNTAX.SHARP-T.7 SYNTAX.SHARP-T.8 SYNTAX.SHARP-C.1 SYNTAX.SHARP-C.2

 SYNTAX.SHARP-C.3 SYNTAX.SHARP-C.4 SYNTAX.SHARP-C.5 SYNTAX.SHARP-C.6

 SYNTAX.SHARP-C.7 SYNTAX.SHARP-A.1 SYNTAX.SHARP-A.2 SYNTAX.SHARP-A.3

 SYNTAX.SHARP-A.4 SYNTAX.SHARP-A.5 SYNTAX.SHARP-A.6 SYNTAX.SHARP-A.7

 SYNTAX.SHARP-A.8 SYNTAX.SHARP-A.9 SYNTAX.SHARP-A.10 SYNTAX.SHARP-A.11

 SYNTAX.SHARP-A.12 SYNTAX.SHARP-A.13 SYNTAX.SHARP-A.14 SYNTAX.SHARP-A.15

 SYNTAX.SHARP-A.16 SYNTAX.SHARP-A.17 SYNTAX.SHARP-A.18 SYNTAX.SHARP-A.19

 SYNTAX.SHARP-A.20 SYNTAX.SHARP-A.21 SYNTAX.SHARP-A.22 SYNTAX.SHARP-A.23

 SYNTAX.SHARP-A.24 SYNTAX.SHARP-A.25 SYNTAX.SHARP-A.26 SYNTAX.SHARP-S.1

 SYNTAX.SHARP-S.2 SYNTAX.SHARP-S.3 SYNTAX.SHARP-S.4 SYNTAX.SHARP-S.5

 SYNTAX.SHARP-S.6 SYNTAX.SHARP-S.7 SYNTAX.SHARP-S.8 SYNTAX.SHARP-S.9

 SYNTAX.SHARP-S.10 SYNTAX.SHARP-P.1 SYNTAX.SHARP-P.2 SYNTAX.SHARP-P.3

 SYNTAX.SHARP-P.4 SYNTAX.SHARP-P.5 SYNTAX.SHARP-CIRCLE.1

 SYNTAX.SHARP-CIRCLE.2 SYNTAX.SHARP-CIRCLE.3 SYNTAX.SHARP-CIRCLE.4

 SYNTAX.SHARP-CIRCLE.5 SYNTAX.SHARP-CIRCLE.6 SYNTAX.SHARP-CIRCLE.7

 SYNTAX.SHARP-PLUS.1 SYNTAX.SHARP-PLUS.2 SYNTAX.SHARP-PLUS.3

 SYNTAX.SHARP-PLUS.4 SYNTAX.SHARP-PLUS.5 SYNTAX.SHARP-PLUS.6

 SYNTAX.SHARP-PLUS.7 SYNTAX.SHARP-PLUS.8 SYNTAX.SHARP-PLUS.9

 SYNTAX.SHARP-PLUS.10 SYNTAX.SHARP-PLUS.11 SYNTAX.SHARP-PLUS.12

 SYNTAX.SHARP-PLUS.13 SYNTAX.SHARP-PLUS.14 SYNTAX.SHARP-PLUS.15

 SYNTAX.SHARP-PLUS.16 SYNTAX.SHARP-BAR.1 SYNTAX.SHARP-BAR.2

 SYNTAX.SHARP-BAR.3 SYNTAX.SHARP-BAR.4 SYNTAX.SHARP-BAR.5

 SYNTAX.SHARP-BAR.6 SYNTAX.SHARP-BAR.7 SYNTAX.SHARP-BAR.8

 SYNTAX.SHARP-BAR.9 SYNTAX.SHARP-BAR.10 SYNTAX.SHARP-WHITESPACE.1

 SYNTAX.SHARP-LESS-THAN.1 SYNTAX.SHARP-CLOSE-PAREN.1

 SYNTAX.SINGLE-ESCAPE-EOF.1 SYNTAX.SINGLE-ESCAPE-EOF.2

 SYNTAX.MULTIPLE-ESCAPE-EOF.1 SYNTAX.MULTIPLE-ESCAPE-EOF.2

 SYNTAX.NUMBER-TOKEN.ERROR.1 SYNTAX.NUMBER-TOKEN.3 SYNTAX.NUMBER-TOKEN.4

 SYNTAX.DOT-TOKEN.1 SYNTAX.DOT-TOKEN.2 SYNTAX.DOT-TOKEN.3

 SYNTAX.DOT-TOKEN.4 SYNTAX.DOT-TOKEN.5 SYNTAX.DOT-TOKEN.6

 SYNTAX.DOT-TOKEN.7 SYNTAX.DOT-TOKEN.8

Test SYNTAX.DOT-ERROR.1 failed

Form: (WITH-STANDARD-IO-SYNTAX

       (LET ((*PACKAGE* (FIND-PACKAGE :CL-TEST)))

         (SIGNALS-ERROR (READ-FROM-STRING ".") READER-ERROR)))

Expected value: T

Actual values: NIL

               SI:|.|

               1.

 SYNTAX.DOT-ERROR.2 SYNTAX.DOT-ERROR.3 SYNTAX.DOT-ERROR.4

 SYNTAX.DOT-ERROR.5 SYNTAX.DOT-ERROR.6 SYNTAX.DOT-ERROR.7

 SYNTAX.RIGHT-PAREN-ERROR.1 SYNTAX.COMMA-ERROR.1 SYNTAX.COMMA-ERROR.2compile-file-test-file.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.fas" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.fas" 

 COMPILE-FILE.1;;; Warning: #<a COMPILE-FILE-TEST-CONDITION.2>

compile-file-test-file-2.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-2.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-2.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-2.fas" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-2.fas" 

 COMPILE-FILE.2;;; Warning: #<a COMPILE-FILE-TEST-CONDITION.2A>

compile-file-test-file-2a.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-2a.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-2a.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-2a.fas" 

Test COMPILE-FILE.2A failed

Form: (COMPILE-FILE-TEST "compile-file-test-file-2a.lsp"

                         'COMPILE-FILE-TEST-FUN.2A

                         :EXPECT-WARNINGS

                         T)

Expected values: T

                 NIL

Actual value: #<a TYPE-ERROR>.

compile-file-test-file-3.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.fas" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.fas" 

 COMPILE-FILE.3compile-file-test-file-3.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.fas" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file-3.fas" 

 COMPILE-FILE.4compile-file-test-file.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.fas" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.fas" 

 COMPILE-FILE.5foo.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.fasl" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.fasl"  COMPILE-FILE.6foo.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.ufsl" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.ufsl" 

Test COMPILE-FILE.6A failed

Form: (COMPILE-FILE-TEST "compile-file-test-file.lsp"

                         'COMPILE-FILE-TEST-FUN.1

                         :OUTPUT-FILE

                         "foo.ufsl")

Expected values: T

                 NIL

Actual value: #<a SIMPLE-ERROR>.

compile-file-test-file.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.fas" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.fas" 

 COMPILE-FILE.7foo.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.implib and object C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.exp


"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.fasl" 

"C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/foo.fasl"  COMPILE-FILE.8compile-file-test-file.c
   Creating library C:/cygwin/home/Jjgarcia/src/ecl-test/ansi/compile-file-test-file.implib and object C:/cygwin/home/Jjgarcia/src/e