asdf-install-tester on sbcl-0.9.9-darwin-ppc - Details

Author:Gary Warren King <gwking@metabang.com>
Version:0.3
Description:A tester for ASDF-Install
Started at:2006-04-15 23:38:33
Ended at:2006-04-15 23:39:34
Elapsed time (seconds):61
Depends On:trivial-http, cl-html-parse, cl-fad, defsystem-compatibility
Most recent change:2006-04-04 09:25:56
Most recent file:/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/asdf-install/asdf-install

REPL Output

;;; ASDF-INSTALL: Downloading 69212 bytes from http://common-lisp.net/project/ait/ait_latest.tar.gz to /Users/gwking/temporary/asdf-test/ASDF-INSTALL-TESTER.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/ASDF-INSTALL-TESTER.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
ait/
ait/asdf-install/
ait/asdf-install/asdf-install
ait/asdf-install/asdf-install.asd
ait/asdf-install/asdf.lisp
ait/asdf-install/COPYRIGHT
ait/asdf-install/defpackage.lisp
ait/asdf-install/digitool.lisp
ait/asdf-install/doc/
ait/asdf-install/doc/index.html
ait/asdf-install/installer.lisp
ait/asdf-install/load-asdf-install.lisp
ait/asdf-install/loader.lisp
ait/asdf-install/Makefile
ait/asdf-install/port.lisp
ait/asdf-install/README
ait/asdf-install/site/
ait/asdf-install/site-systems/
ait/asdf-install/split-sequence.lisp
ait/asdf-install-dates.asd
ait/asdf-install-tester.asd
ait/COPYING
ait/dev/
ait/dev/allegro.lisp
ait/dev/clisp.lisp
ait/dev/closer-test.lisp
ait/dev/definitions.lisp
ait/dev/http-download.lisp
ait/dev/implementation.lisp
ait/dev/lisp-implementation.lisp
ait/dev/macros.lisp
ait/dev/main.lisp
ait/dev/mt-asdf-install-1
ait/dev/notes.text
ait/dev/openmcl.lisp
ait/dev/package.lisp
ait/dev/remove-1-asdf-system
ait/dev/resolve-symbolic-link
ait/dev/sbcl.lisp
ait/dev/settings.lisp
ait/dev/system-extraction.lisp
ait/dev/update-asdf-packages.lisp
ait/dev/utilities.lisp
ait/README
ait/website/
ait/website/redirected-index.html
ait/website/source/
ait/website/source/images/
ait/website/source/index.lml

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/" ;;; ASDF-INSTALL: Downloading package DEFSYSTEM-COMPATIBILITY, required by asdf-install-tester

;;; ASDF-INSTALL: Downloading 8662 bytes from http://common-lisp.net/project/cl-containers/defsystem-compatibility/defsystem-compatibility_latest.tar.gz to /Users/gwking/temporary/asdf-test/defsystem-compatibility.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/defsystem-compatibility.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
defsystem-compatibility/
defsystem-compatibility/COPYING
defsystem-compatibility/defsystem-compatibility-test.asd
defsystem-compatibility/defsystem-compatibility.asd
defsystem-compatibility/dev/
defsystem-compatibility/dev/api.lisp
defsystem-compatibility/dev/asdf.lisp
defsystem-compatibility/dev/defsystem-compatibility.lisp
defsystem-compatibility/dev/glu.lisp
defsystem-compatibility/dev/mini-module-system.lisp
defsystem-compatibility/dev/mk-defsystem.lisp
defsystem-compatibility/dev/package.lisp
defsystem-compatibility/unit-tests/
defsystem-compatibility/unit-tests/asdf-systems.lisp
defsystem-compatibility/unit-tests/package.lisp
defsystem-compatibility/unit-tests/tests.lisp
defsystem-compatibility/website/
defsystem-compatibility/website/source/
defsystem-compatibility/website/source/images/
defsystem-compatibility/website/source/index.lml

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/" ;;; ASDF-INSTALL: Downloading package METATILITIES-BASE, required by defsystem-compatibility

;;; ASDF-INSTALL: Downloading 271337 bytes from http://common-lisp.net/project/cl-containers/metatilities/metatilities_latest.tar.gz to /Users/gwking/temporary/asdf-test/metatilities-base.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/metatilities-base.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
metatilities/
metatilities/COPYING
metatilities/dev/
metatilities/dev/allegro/
metatilities/dev/allegro/generic-interface-support.lisp
metatilities/dev/allegro/generic-lisp.lisp
metatilities/dev/contrib/
metatilities/dev/contrib/mcl/
metatilities/dev/contrib/mcl/appearance-mcl.lisp
metatilities/dev/contrib/mcl/appleevent-toolkit.lisp
metatilities/dev/contrib/mcl/eval-apple-script.lisp
metatilities/dev/contrib/mcl/framework-0.91/
metatilities/dev/contrib/mcl/framework-0.91/CFBundle.lisp
metatilities/dev/contrib/mcl/framework-0.91/cfm-fp-to-macho-fp.lisp
metatilities/dev/contrib/mcl/framework-0.91/framework.lisp
metatilities/dev/contrib/mcl/framework-0.91/package.lisp
metatilities/dev/contrib/mcl/framework-0.91/reader-macro.lisp
metatilities/dev/contrib/mcl/framework-0.91/ReadMe.lisp
metatilities/dev/contrib/mcl/Image-Dialog-Item.lisp
metatilities/dev/contrib/mcl/image-window.lisp
metatilities/dev/contrib/mcl/processes.lisp
metatilities/dev/contrib/mcl/profile.lisp
metatilities/dev/contrib/mcl/progress-indicator.lisp
metatilities/dev/contrib/mcl/qt-midi.lisp
metatilities/dev/contrib/mcl/scrolling-windows.lisp
metatilities/dev/contrib/mcl/Speech-Recognition-Manager.lisp
metatilities/dev/contrib/mcl/windoid-key-events.lisp
metatilities/dev/contrib/metering.lisp
metatilities/dev/defclass-star.lisp
metatilities/dev/define-class.lisp
metatilities/dev/dynamic-class.lisp
metatilities/dev/experimental/
metatilities/dev/experimental/write-missing-generics.lisp
metatilities/dev/generic-interface.lisp
metatilities/dev/generic-lisp.lisp
metatilities/dev/l0-arrays.lisp
metatilities/dev/l0-clos.lisp
metatilities/dev/l0-files.lisp
metatilities/dev/l0-macros.lisp
metatilities/dev/l0-utils.lisp
metatilities/dev/lispworks/
metatilities/dev/lispworks/generic-interface-support.lisp
metatilities/dev/lispworks/generic-lisp.lisp
metatilities/dev/load-glu.lisp
metatilities/dev/mcl/
metatilities/dev/mcl/generic-interface-support.lisp
metatilities/dev/mcl/generic-lisp.lisp
metatilities/dev/mcl/pop-up-menu.lisp
metatilities/dev/metatilities.system
metatilities/dev/names.lisp
metatilities/dev/notes.text
metatilities/dev/openmcl/
metatilities/dev/openmcl/generic-interface-support.lisp
metatilities/dev/openmcl/generic-lisp.lisp
metatilities/dev/package.lisp
metatilities/dev/sbcl/
metatilities/dev/sbcl/generic-interface-support.lisp
metatilities/dev/sbcl/generic-lisp.lisp
metatilities/dev/sbcl-warnings.text
metatilities/dev/set-equal.lisp
metatilities/dev/unsupported/
metatilities/dev/unsupported/generic-interface-support.lisp
metatilities/dev/unsupported/generic-lisp.lisp
metatilities/dev/utilities/
metatilities/dev/utilities/allegro/
metatilities/dev/utilities/allegro/tcp-allegro.lisp
metatilities/dev/utilities/anaphoric.lisp
metatilities/dev/utilities/copy-file.lisp
metatilities/dev/utilities/dates-and-times.lisp
metatilities/dev/utilities/debugging-utils.lisp
metatilities/dev/utilities/defsystem-compatibility.lisp
metatilities/dev/utilities/dev/
metatilities/dev/utilities/files.lisp
metatilities/dev/utilities/graham.lisp
metatilities/dev/utilities/lispworks/
metatilities/dev/utilities/lispworks/tcp-lispworks.lisp
metatilities/dev/utilities/locks.lisp
metatilities/dev/utilities/macros.lisp
metatilities/dev/utilities/make-allocatable.lisp
metatilities/dev/utilities/mcl/
metatilities/dev/utilities/mcl/tcp-mcl.lisp
metatilities/dev/utilities/more-view-and-window-utilities.lisp
metatilities/dev/utilities/notifications.lisp
metatilities/dev/utilities/openmcl/
metatilities/dev/utilities/openmcl/tcp-openmcl.lisp
metatilities/dev/utilities/package-additional.lisp
metatilities/dev/utilities/searching.lisp
metatilities/dev/utilities/sequences.lisp
metatilities/dev/utilities/settings.lisp
metatilities/dev/utilities/source-compare.lisp
metatilities/dev/utilities/spy.lisp
metatilities/dev/utilities/strings.lisp
metatilities/dev/utilities/test-dates-and-times.lisp
metatilities/dev/utilities/test-files.lisp
metatilities/dev/utilities/threads.lisp
metatilities/dev/utilities/utilities.lisp
metatilities/dev/utilities/views-and-windows.lisp
metatilities/metabang-dynamic-classes.asd
metatilities/metatilities-base.asd
metatilities/metatilities.asd
metatilities/website/
metatilities/website/source/
metatilities/website/source/images/
metatilities/website/source/index.lml

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/" ;;; ASDF-INSTALL: Downloading package MOPTILITIES, required by metatilities-base

;;; ASDF-INSTALL: Downloading 11213 bytes from http://common-lisp.net/project/cl-containers/moptilities/moptilities_latest.tar.gz to /Users/gwking/temporary/asdf-test/moptilities.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/moptilities.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
moptilities/
moptilities/COPYING
moptilities/dev/
moptilities/dev/moptilities.lisp
moptilities/dev/notes.text
moptilities/moptilities-test.asd
moptilities/moptilities.asd
moptilities/test/
moptilities/test/tests.lisp
moptilities/version
moptilities/website/
moptilities/website/source/
moptilities/website/source/images/
moptilities/website/source/index.lml

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/moptilities/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/moptilities/" ;;; ASDF-INSTALL: Downloading package CLOSER-MOP, required by moptilities

;;; ASDF-INSTALL: Downloading 20656 bytes from http://common-lisp.net/project/cl-containers/closer-mop/closer-mop_latest.tar.gz to /Users/gwking/temporary/asdf-test/closer-mop.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/closer-mop.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
closer-mop/
closer-mop/allegro/
closer-mop/allegro/closer-mop-packages.lisp
closer-mop/allegro/closer-mop.lisp
closer-mop/clisp/
closer-mop/clisp/closer-mop-packages.lisp
closer-mop/clisp/closer-mop.lisp
closer-mop/closer-mop-utility-packages.lisp
closer-mop/closer-mop.asd
closer-mop/features.lisp
closer-mop/features.txt
closer-mop/lispworks/
closer-mop/lispworks/closer-mop-packages.lisp
closer-mop/lispworks/closer-mop.lisp
closer-mop/mcl/
closer-mop/mcl/closer-mop-packages.lisp
closer-mop/mcl/closer-mop.lisp
closer-mop/pcl/
closer-mop/pcl/closer-mop-packages.lisp
closer-mop/pcl/closer-mop.lisp
closer-mop/release-notes.txt
closer-mop/supported-cls.txt
closer-mop/test/
closer-mop/test/jeffs-code.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/" ;;; ASDF-INSTALL: Downloading package LW-COMPAT, required by closer-mop

;;; ASDF-INSTALL: Downloading 1817 bytes from http://common-lisp.net/project/cl-containers/lw-compat/lw-compat_latest.tar.gz to /Users/gwking/temporary/asdf-test/lw-compat.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/lw-compat.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
lw-compat/
lw-compat/lw-compat-package.lisp
lw-compat/lw-compat.asd
lw-compat/lw-compat.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/lw-compat/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/lw-compat/" 
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/lw-compat/lw-compat-package.lisp" (written 04 APR 2006 09:27:44 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE #:LISPWORKS ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/lw-compat/lw-compat-package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/lw-compat/lw-compat.lisp" (written 04 APR 2006 09:27:44 AM):
; compiling (IN-PACKAGE #:LISPWORKS)
; compiling (DEFINE-MODIFY-MACRO APPENDF ...)
; compiling (DEFINE-MODIFY-MACRO NCONCF ...)
; compiling (DEFMACRO REBINDING ...)
; compiling (DEFINE-MODIFY-MACRO REMOVEF ...)
; compiling (DEFMACRO WHEN-LET ...)
; compiling (DEFMACRO WHEN-LET* ...)
; compiling (DEFMACRO WITH-UNIQUE-NAMES ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/lw-compat/lw-compat.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/pcl/closer-mop-packages.lisp" (written 04 APR 2006 09:27:57 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE #:CLOSER-MOP ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/pcl/closer-mop-packages.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/pcl/closer-mop.lisp" (written 04 APR 2006 09:27:57 AM):
; compiling (IN-PACKAGE :CLOSER-MOP)
; compiling (DEFUN REQUIRED-ARGS ...)
; compiling (DEFUN MODIFY-ACCESSORS ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD INITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD REINITIALIZE-INSTANCE ...)
; compiling (DEFMETHOD REINITIALIZE-INSTANCE ...)
; compiling (DEFGENERIC TRANSFORM-SPECIALIZER ...)
; compiling (DEFUN ENSURE-METHOD ...)
; compiling (DEFVAR *STANDARD-SLOT-KEYS* ...)
; compiling (DEFUN FIX-SLOT-INITARGS ...)
; compiling (DEFGENERIC TYPEP ...)
; compiling (DEFGENERIC SUBTYPEP ...)
; compiling (PUSHNEW :CLOSER-MOP ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/pcl/closer-mop.fasl written
; compilation finished in 0:00:02
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/closer-mop-utility-packages.lisp" (written 04 APR 2006 09:27:56 AM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE #:CLOSER-COMMON-LISP ...)
; compiling (LET (#) ...)
; compiling (DEFPACKAGE #:CLOSER-COMMON-LISP-USER ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/closer-mop/closer-mop-utility-packages.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/moptilities/dev/moptilities.lisp" (written 04 APR 2006 09:27:32 AM):
; compiling (IN-PACKAGE CL-USER)
; compiling (REQUIRE (QUOTE SB-INTROSPECT))
; compiling (DEFPACKAGE #:METABANG.MOPTILITIES ...)
; compiling (IN-PACKAGE #:MOPTILITIES)
; compiling (DEFMACRO NYI ...)
; compiling (DEFGENERIC GET-CLASS ...)
; compiling (DEFGENERIC SUBCLASSP ...)
; compiling (DEFMETHOD SUBCLASSP ...)
; compiling (DEFUN FINALIZE-CLASS-IF-NECESSARY ...)
; compiling (DEFUN SUPERCLASSES ...)
; compiling (DEFUN DIRECT-SUPERCLASSES ...)
; compiling (DEFUN DIRECT-SUBCLASSES ...)
; compiling (DEFGENERIC METHOD-NAME ...)
; compiling (DEFGENERIC GET-METHOD ...)
; compiling (DEFGENERIC SLOT-NAMES ...)
; compiling (DEFGENERIC SLOT-PROPERTIES ...)
; compiling (DEFGENERIC GET-SLOT-DEFINITION ...)
; compiling (DEFGENERIC DIRECT-SLOT-NAMES ...)
; compiling (DEFGENERIC READER-METHOD-P ...)
; compiling (DEFGENERIC WRITER-METHOD-P ...)
; compiling (DEFUN MAP-METHODS ...)
; compiling (DEFUN REMOVE-METHODS ...)
; compiling (DEFUN REMOVE-METHODS-IF ...)
; compiling (DEFUN GENERIC-FUNCTIONS ...)
; compiling (DEFUN DIRECT-SPECIALIZERS-OF ...)
; compiling (DEFUN SPECIALIZERS-OF ...)
; compiling (DEFUN MAP-SUBCLASSES ...)
; compiling (DEFUN SUBCLASSES ...)
; compiling (DEFUN IN-ORDER-P ...)
; compiling (DEFUN GET-STRUCTURE ...)
; compiling (DEFUN FUNCTION-ARGLIST ...)
; compiling (DEFUN MOPU-CLASS-INITARGS ...)
; compiling (DEFGENERIC EQL-SPECIALIZER-P ...)
; compiling (DEFUN DEFAULT-INITARGS ...)
; compiling (DEFUN LEAF-CLASS-P ...)
; compiling (DEFUN LEAF-SUBCLASSES ...)
; compiling (DEFGENERIC CLASS-NAME-OF ...)
; compiling (DEFGENERIC COPY-TEMPLATE ...)
; compiling (DEFMETHOD COPY-TEMPLATE ...)
; compiling (DEFGENERIC WHEN-GARBAGE-COLLECTED ...)
; compiling (DEFMETHOD WHEN-GARBAGE-COLLECTED ...)
; compiling (DEFUN CARE-WHEN-GARBAGE-COLLECTED ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/moptilities/dev/moptilities.lisp
; in: DEFUN CARE-WHEN-GARBAGE-COLLECTED
;     (DEFUN METABANG.MOPTILITIES::CARE-WHEN-GARBAGE-COLLECTED
;          (METABANG.MOPTILITIES::OBJECT)
;     (METABANG.MOPTILITIES::NYI
;      'METABANG.MOPTILITIES::CARE-WHEN-GARBAGE-COLLECTED))
; --> PROGN EVAL-WHEN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA METABANG.MOPTILITIES::CARE-WHEN-GARBAGE-COLLECTED
;                          (METABANG.MOPTILITIES::OBJECT)
;                          (BLOCK
;                              METABANG.MOPTILITIES::CARE-WHEN-GARBAGE-COLLECTED
;                            (METABANG.MOPTILITIES::NYI
;                             'METABANG.MOPTILITIES::CARE-WHEN-GARBAGE-COLLECTED)))
; 
; caught STYLE-WARNING:
;   The variable OBJECT is defined but never used.

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/moptilities/dev/moptilities.fasl written
; compilation finished in 0:00:03
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {4000A121}> on
   #<CL-SOURCE-FILE "moptilities" {4000A131}>.
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/package.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE :COMMON-LISP-USER)
; compiling (DEFPACKAGE #:METABANG.UTILITIES ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-utils.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFMACRO WITH-STANDARD-PRINTING ...)
; compiling (DEFUN NEQ ...)
; compiling (DECLAIM (INLINE NEQ))
; compiling (DEFINE-COMPILER-MACRO NEQ ...)
; compiling (DEFUN FORM-SYMBOL-IN-PACKAGE ...)
; compiling (DEFUN FORM-SYMBOL ...)
; compiling (DEFUN FORM-KEYWORD ...)
; compiling (DEFUN FORM-UNINTERNED-SYMBOL ...)
; compiling (DEFUN CURRENT-LOAD-FILE ...)
; compiling (DEFMACRO WITH-UNIQUE-NAMES ...)
; compiling (DEFUN ENSURE-LIST ...)
; 
; caught STYLE-WARNING:
;   using deprecated EVAL-WHEN situation names EVAL LOAD COMPILE

; compiling (DEFVAR *NEWSYM-COUNTER* ...)
; compiling (DEFUN NEWSYM ...)
; compiling (DEFUN EXPORT-EXPORTED-SYMBOLS ...)
; compiling (DEFGENERIC LENGTH-AT-LEAST-P ...)
; compiling (DEFMETHOD LENGTH-AT-LEAST-P ...)
; compiling (DEFMETHOD LENGTH-AT-LEAST-P ...)
; compiling (DEFGENERIC LENGTH-AT-MOST-P ...)
; compiling (DEFMETHOD LENGTH-AT-MOST-P ...)
; compiling (DEFMETHOD LENGTH-AT-MOST-P ...)
; compiling (DECLAIM (INLINE LENGTH-1-LIST-P))
; compiling (DEFUN LENGTH-1-LIST-P ...)
; compiling (DEFUN NEARLY-ZERO-P ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-utils.lisp
; in: DEFUN NEARLY-ZERO-P
;     (< 0.0 METABANG.UTILITIES::X)
; --> > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.

;     (> METABANG.UTILITIES::THRESHOLD METABANG.UTILITIES::X)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (> METABANG.UTILITIES::X METABANG.UTILITIES::THRESHOLD)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (< 0.0 METABANG.UTILITIES::X)
; --> > IF 
; ==>
;   (> SB-C::Y SB-C::X)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.

;     (> METABANG.UTILITIES::X METABANG.UTILITIES::THRESHOLD)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (> METABANG.UTILITIES::THRESHOLD METABANG.UTILITIES::X)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; compiling (DEFUN NEARLY-EQUAL-P ...)
; compiling (DEFPARAMETER +WHITESPACE-CHARACTERS+ ...)
; compiling (DEFUN WHITESPACEP ...)
; compiling (DEFUN DOTTED-PAIR-P ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-utils.fasl written
; compilation finished in 0:00:01
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {10008691}> on
   #<CL-SOURCE-FILE "l0-utils" {100086A1}>.
STYLE-WARNING: redefining FORM-SYMBOL-IN-PACKAGE in DEFUN
STYLE-WARNING: redefining FORM-SYMBOL in DEFUN
STYLE-WARNING: redefining FORM-KEYWORD in DEFUN
STYLE-WARNING: redefining FORM-UNINTERNED-SYMBOL in DEFUN
STYLE-WARNING: redefining NEWSYM in DEFUN
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-macros.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFMACRO DEPRECATED ...)
; compiling (DEFMACRO ONCE-ONLY ...)
; compiling (DEFMACRO WITH-VARIABLES ...)
; compiling (DEFMACRO EVAL-ALWAYS ...)
; compiling (DEFMACRO DEFCLASS-PROPERTY ...)
; compiling (DEFMACRO WITH-ATOMIC-EXECUTION ...)
; compiling (DEFMACRO HANDLER-BIND* ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-macros.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-arrays.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN LINEARIZE-ARRAY ...)
; compiling (DEFUN COPY-ARRAY ...)
; compiling (DEFUN MAPARRAY ...)
; compiling (DEFUN MAPARRAY! ...)
; compiling (DEFUN ARRAY-ROW ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-arrays.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-clos.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFMETHOD RESET ...)
; compiling (DECLAIM (SPECIAL *SAMEP-TOLERANCE*))
; compiling (DEFVAR *SAMEP-TOLERANCE* ...)
; compiling (DECLAIM (SPECIAL *SAMEP-TEST*))
; compiling (DEFVAR *SAMEP-TEST* ...)
; compiling (DEFGENERIC SAMEP ...)
; compiling (DEFGENERIC NEARLY-SAMEP ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-clos.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-files.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN PATHNAME-NAME+TYPE ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/l0-files.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/set-equal.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFUN SET-EQUAL ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/set-equal.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/generic-lisp.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFVAR *DEFAULT-INTERFACE* ...)
; compiling (DEFUN DEFAULT-INTERFACE ...)
; compiling (DEFUN (SETF DEFAULT-INTERFACE) ...)
; compiling (DEFGENERIC IS-INTERFACE-AVAILABLE-P ...)
; compiling (DEFMETHOD IS-INTERFACE-AVAILABLE-P ...)
; compiling (DEFUN IS-DEFAULT-INTERFACE-AVAILABLE-P ...)
; compiling (DEFMETHOD QUIT-LISP* ...)
; compiling (DEFUN QUIT-LISP ...)
; compiling (DEFGENERIC TOTAL-BYTES-ALLOCATED* ...)
; compiling (DEFUN TOTAL-BYTES-ALLOCATED ...)
; compiling (DEFGENERIC GC-TIME* ...)
; compiling (DEFUN GC-TIME ...)
; compiling (DEFGENERIC COLLECT-GARBAGE* ...)
; compiling (DEFUN COLLECT-GARBAGE ...)
; compiling (DEFMACRO MAKE-LOAD-FORM* ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/generic-lisp.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: implicitly creating new generic function QUIT-LISP*
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/generic-interface.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DECLAIM (SPECIAL *DEVELOPMENT-MODE* ...))
; compiling (DEFVAR *DEVELOPMENT-MODE* ...)
; compiling (DEFVAR *USE-NATIVE-DEBUGGER* ...)
; compiling (DEFGENERIC MAKE-PROGRESS-BAR ...)
; compiling (DEFGENERIC PROGRESS-BAR-VALUE ...)
; compiling (DEFGENERIC (SETF PROGRESS-BAR-VALUE) ...)
; compiling (DEFGENERIC CLOSE-PROGRESS-BAR ...)
; compiling (DEFVAR *DUMMY-PROGRESS-VARIABLE*)
; compiling (DEFVAR *PROGRESS-BAR-COUNT* ...)
; compiling (DEFMACRO WITH-PROGRESS-BAR ...)
; compiling (DEFMACRO WITH-PROCESS-MESSAGE ...)
; compiling (DEFMACRO HANDLE-ERRORS ...)
; compiling (DEFGENERIC GUI-ERROR ...)
; compiling (DEFGENERIC GUI-WARN ...)
; compiling (DEFGENERIC MAKE-COLOR** ...)
; compiling (DEFMETHOD INTERFACE-BEEP* ...)
; compiling (DEFMETHOD INTERFACE-BEEP ...)
; compiling (DEFGENERIC QUIT-LISP* ...)
; compiling (DEFGENERIC Y-OR-N-QUESTION* ...)
; compiling (DEFMETHOD MAKE-PROGRESS-BAR ...)
; compiling (DEFMETHOD PROGRESS-BAR-VALUE ...)
; compiling (DEFMETHOD (SETF PROGRESS-BAR-VALUE) ...)
; compiling (DEFMETHOD CLOSE-PROGRESS-BAR ...)
; compiling (DEFMETHOD REPORT-CONDITION ...)
; compiling (DEFMETHOD GUI-ERROR* ...)
; compiling (DEFMETHOD GUI-ERROR ...)
; compiling (DEFMETHOD GUI-WARN* ...)
; compiling (DEFMETHOD GUI-WARN ...)
; compiling (DEFMETHOD MAKE-COLOR** ...)
; compiling (DEFMETHOD MAKE-COLOR* ...)
; compiling (DEFMETHOD MAKE-GRAY* ...)
; compiling (DEFMETHOD MAKE-GRAY ...)
; compiling (DEFMETHOD MAKE-SCALED-COLOR* ...)
; compiling (DEFMETHOD MAKE-SCALED-COLOR ...)
; compiling (DEFMETHOD Y-OR-N-QUESTION* ...)
; compiling (DEFUN Y-OR-N-QUESTION ...)
; compiling (DEFMETHOD CHOOSE-FILE-QUESTION* ...)
; compiling (DEFUN CHOOSE-FILE-QUESTION ...)
; compiling (DEFMETHOD CHOOSE-NEW-FILE-QUESTION* ...)
; compiling (DEFUN CHOOSE-NEW-FILE-QUESTION ...)
; compiling (DEFMETHOD CHOOSE-DIRECTORY-QUESTION* ...)
; compiling (DEFUN CHOOSE-DIRECTORY-QUESTION ...)
; compiling (DEFMETHOD CHOOSE-ITEM-QUESTION* ...)
; compiling (DEFUN CHOOSE-ITEM-QUESTION ...)
; compiling (DEFMETHOD CHOOSE-ITEM-FROM-PUP* ...)
; compiling (DEFUN CHOOSE-ITEM-FROM-PUP ...)
; compiling (DEFUN CHOOSE-ITEM-FROM-PUP-NO-SINGLETONS ...)
; compiling (DEFMETHOD MAKE-UI-POINT* ...)
; compiling (DEFUN MAKE-UI-POINT ...)
; compiling (DEFMETHOD PROCESS-PARAMETERS* ...)
; compiling (DEFMETHOD PROCESS-PARAMETERS ...)
; compiling (DEFMETHOD PUT-ITEM-ON-CLIPBOARD* ...)
; compiling (DEFMETHOD PUT-ITEM-ON-CLIPBOARD ...)
; compiling (DEFMETHOD INSPECT-THING* ...)
; compiling (DEFMETHOD INSPECT-THING ...)
; compiling (DEFUN INSPECT-THINGS ...)
; compiling (DEFMETHOD SOUND-NOTE* ...)
; compiling (DEFMETHOD SOUND-NOTE ...)
; compiling (DEFMETHOD STOP-NOTES* ...)
; compiling (DEFUN STOP-NOTES ...)
; compiling (DEFMETHOD SELECT-INSTRUMENT* ...)
; compiling (DEFMETHOD SELECT-INSTRUMENT ...)
; compiling (DEFUN QUERY-USER-FOR-STRING ...)
; compiling (DEFUN QUERY-USER-FOR-INTEGER ...)
; compiling (DEFMETHOD PROMPT-FOR* ...)
; compiling (DEFMETHOD PROMPT-FOR* ...)
; compiling (DEFMETHOD PROMPT-FOR* ...)
; compiling (DEFMETHOD PROMPT-FOR ...)
; compiling (DEFMETHOD SHELL-COMMAND* ...)
; compiling (DEFMETHOD SHELL-COMMAND ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/generic-interface.fasl written
; compilation finished in 0:00:05
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/defclass-star.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFVAR *AUTOMATIC-SLOT-ACCESSORS?* ...)
; compiling (DEFVAR *AUTOMATIC-SLOT-INITARGS?* ...)
; compiling (DEFVAR *CLOS-SLOT-OPTIONS* ...)
; compiling (DEFUN PARSE-BRIEF-SLOT ...)
; compiling (DEFMACRO DEFCLASS-BRIEF ...)
; compiling (DEFPARAMETER *DEFCLASS-COPY-CONDITION-FUNCTION* ...)
; compiling (DEFVAR *DEFCLASS-GENERATE-MAKE-LOAD-FORM* ...)
; compiling (DEFCLASS-PROPERTY DEFCLASS*-SUPERCLASSES)
; compiling (DEFUN CLASS-COPYABLE-P ...)
; compiling (DEFMACRO DEFCLASS* ...)
; compiling (DEFPARAMETER *DEFCONDITION-OPTIONS* ...)
; compiling (DEFMACRO DEFCONDITION ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/defclass-star.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: implicitly creating new generic function DEFCLASS*-SUPERCLASSES
STYLE-WARNING:
   implicitly creating new generic function (SETF DEFCLASS*-SUPERCLASSES)
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/define-class.lisp" (written 04 APR 2006 09:27:20 AM):
; compiling (IN-PACKAGE METATILITIES)
; compiling (DEFVAR *DEFINE-CLASS-FORM* ...)
; compiling (DEFUN SIMPLE-DEFINE-CLASS ...)
; compiling (DEFUN SIMPLE-DEFINE-CLASS-NAME ...)
; compiling (DEFUN DEFINE-CLASS ...)
; compiling (DEFUN FIND-EXISTING-SUBCLASS ...)
; compiling (DEFUN FIND-OR-CREATE-CLASS ...)
; compiling (DEFUN REMOVE-REDUNDANT-CLASSES ...)
; compiling (DEFUN CLASS-REDUNDANT-P ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/metatilities/dev/define-class.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: implicitly creating new generic function RESET
STYLE-WARNING: implicitly creating new generic function INTERFACE-BEEP*
STYLE-WARNING: implicitly creating new generic function INTERFACE-BEEP
STYLE-WARNING: redefining QUIT-LISP* in DEFGENERIC
STYLE-WARNING: implicitly creating new generic function REPORT-CONDITION
STYLE-WARNING: implicitly creating new generic function GUI-ERROR*
STYLE-WARNING: implicitly creating new generic function GUI-WARN*
STYLE-WARNING: implicitly creating new generic function MAKE-COLOR*
STYLE-WARNING: implicitly creating new generic function MAKE-GRAY*
STYLE-WARNING: implicitly creating new generic function MAKE-GRAY
STYLE-WARNING: implicitly creating new generic function MAKE-SCALED-COLOR*
STYLE-WARNING: implicitly creating new generic function MAKE-SCALED-COLOR
STYLE-WARNING: implicitly creating new generic function CHOOSE-FILE-QUESTION*
STYLE-WARNING:
   implicitly creating new generic function CHOOSE-NEW-FILE-QUESTION*
STYLE-WARNING:
   implicitly creating new generic function CHOOSE-DIRECTORY-QUESTION*
STYLE-WARNING: implicitly creating new generic function CHOOSE-ITEM-QUESTION*
STYLE-WARNING: implicitly creating new generic function CHOOSE-ITEM-FROM-PUP*
STYLE-WARNING: implicitly creating new generic function MAKE-UI-POINT*
STYLE-WARNING: implicitly creating new generic function PROCESS-PARAMETERS*
STYLE-WARNING: implicitly creating new generic function PROCESS-PARAMETERS
STYLE-WARNING: implicitly creating new generic function PUT-ITEM-ON-CLIPBOARD*
STYLE-WARNING: implicitly creating new generic function PUT-ITEM-ON-CLIPBOARD
STYLE-WARNING: implicitly creating new generic function INSPECT-THING*
STYLE-WARNING: implicitly creating new generic function INSPECT-THING
STYLE-WARNING: implicitly creating new generic function SOUND-NOTE*
STYLE-WARNING: implicitly creating new generic function SOUND-NOTE
STYLE-WARNING: implicitly creating new generic function STOP-NOTES*
STYLE-WARNING: implicitly creating new generic function SELECT-INSTRUMENT*
STYLE-WARNING: implicitly creating new generic function SELECT-INSTRUMENT
STYLE-WARNING: implicitly creating new generic function PROMPT-FOR*
STYLE-WARNING: implicitly creating new generic function PROMPT-FOR
STYLE-WARNING: implicitly creating new generic function SHELL-COMMAND*
STYLE-WARNING: implicitly creating new generic function SHELL-COMMAND
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition
;   printed 10 notes
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/package.lisp" (written 04 APR 2006 09:26:53 AM):
; compiling (IN-PACKAGE :COMMON-LISP-USER)
; compiling (DEFPACKAGE #:DEFSYSTEM-COMPATIBILITY ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/api.lisp" (written 04 APR 2006 09:26:53 AM):
; compiling (IN-PACKAGE DEFSYSTEM-COMPATIBILITY)
; compiling (DEFGENERIC ASSOCIATED-TEST-SYSTEM* ...)
; compiling (DEFGENERIC ENSURE-SYSTEM-NAME* ...)
; compiling (DEFGENERIC FILENAME-LOOKS-LIKE-SYSTEM-FILE-P* ...)
; compiling (DEFGENERIC FIND-SYSTEM* ...)
; compiling (DEFGENERIC LOADED-SYSTEMS* ...)
; compiling (DEFGENERIC MAP-SYSTEM-FILES ...)
; compiling (DEFGENERIC REGISTERED-SYSTEMS* ...)
; compiling (DEFGENERIC SYSTEM-DEPENDENCIES* ...)
; compiling (DEFGENERIC SYSTEM-NAME-FOR-DISPLAY* ...)
; compiling (DEFGENERIC SYSTEM-PROPERTY* ...)
; compiling (DEFGENERIC SYSTEM-SOURCE-FILE* ...)
; compiling (DEFGENERIC SYSTEM-SUB-SYSTEMS* ...)
; compiling (DEFGENERIC TOP-LEVEL-SYSTEM-P* ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/api.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/defsystem-compatibility.lisp" (written 04 APR 2006 09:26:53 AM):
; compiling (IN-PACKAGE DEFSYSTEM-COMPATIBILITY)
; compiling (DEFPARAMETER *PREFERED-SYSTEM-DEFINER* ...)
; compiling (DEFMETHOD FIND-SYSTEM* ...)
; compiling (DEFMETHOD FIND-SYSTEM* ...)
; compiling (DEFPARAMETER *PREFERED-DEFINER-FOR-SYSTEMS* ...)
; compiling (DEFMETHOD SELECT-SYSTEM-DEFINER ...)
; compiling (DEFMETHOD SELECT-SYSTEM-DEFINER ...)
; compiling (DEFMETHOD SELECT-SYSTEM-DEFINER ...)
; compiling (DEFUN SELECT-SYSTEM-DEFINER% ...)
; compiling (DEFUN REGISTERED-SYSTEMS ...)
; compiling (DEFUN LOADED-SYSTEMS ...)
; compiling (DEFUN FIND-SYSTEM ...)
; compiling (DEFUN ASSOCIATED-TEST-SYSTEM ...)
; compiling (DEFUN SYSTEM-SUB-SYSTEMS ...)
; compiling (DEFUN SYSTEM-PROPERTY ...)
; compiling (DEFUN SYSTEM-SOURCE-FILE ...)
; compiling (DEFUN TOP-LEVEL-SYSTEM-P ...)
; compiling (DEFUN SYSTEM-NAME-FOR-DISPLAY ...)
; compiling (DEFUN ENSURE-SYSTEM-NAME ...)
; compiling (DEFUN FILENAME-LOOKS-LIKE-SYSTEM-FILE-P ...)
; compiling (DEFUN SYSTEM-DEPENDENCIES ...)
; compiling (DEFUN SYSTEM-SOURCE-DIRECTORY ...)
; compiling (DEFUN COLLECT-SYSTEM-DEPENDENCIES ...)
; compiling (DEFUN MAP-SYSTEM-DEPENDENCIES ...)
; compiling (DEFMETHOD MAP-SYSTEM-FILES ...)
; compiling (DEFMETHOD MAP-SYSTEM-FILES ...)
; compiling (DEFUN COLLECT-SYSTEM-FILES ...)
; compiling (DEFUN PATHNAME-FOR-SYSTEM-FILE ...)
; compiling (DEFUN ENSURE-STRING ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/defsystem-compatibility.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/asdf.lisp" (written 04 APR 2006 09:26:53 AM):
; compiling (IN-PACKAGE DEFSYSTEM-COMPATIBILITY)
; compiling (DEFPARAMETER *RELATIVE-PATHNAME* ...)
; compiling (DEFMETHOD REGISTERED-SYSTEMS* ...)
; compiling (DEFMETHOD LOADED-SYSTEMS* ...)
; compiling (DEFMETHOD ASSOCIATED-TEST-SYSTEM* ...)
; compiling (DEFMETHOD SYSTEM-SUB-SYSTEMS* ...)
; compiling (DEFMETHOD TOP-LEVEL-SYSTEM-P* ...)
; compiling (DEFMETHOD SYSTEM-NAME-FOR-DISPLAY* ...)
; compiling (DEFMETHOD SYSTEM-SOURCE-FILE* ...)
; compiling (DEFMETHOD ENSURE-SYSTEM-NAME* ...)
; compiling (DEFMETHOD ENSURE-SYSTEM-NAME* ...)
; compiling (DEFMETHOD FILENAME-LOOKS-LIKE-SYSTEM-FILE-P* ...)
; compiling (DEFMETHOD SYSTEM-DEPENDENCIES* ...)
; compiling (DEFUN SAFE-SLOT-VALUE ...)
; compiling (DEFMETHOD %MAP-SYSTEM-FILES ...)
; compiling (DEFMETHOD %MAP-SYSTEM-FILES ...)
; compiling (DEFMETHOD %MAP-SYSTEM-FILES ...)
; compiling (DEFMETHOD SYSTEM-PROPERTY* ...)
; compiling (DEFMETHOD SELECT-SYSTEM-DEFINER ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/defsystem-compatibility/dev/asdf.fasl written
; compilation finished in 0:00:01
STYLE-WARNING: implicitly creating new generic function SELECT-SYSTEM-DEFINER
STYLE-WARNING: implicitly creating new generic function %MAP-SYSTEM-FILES
;;; ASDF-INSTALL: Downloading package CL-FAD, required by asdf-install-tester

;;; ASDF-INSTALL: Downloading 10097 bytes from http://weitz.de/files/cl-fad.tar.gz to /Users/gwking/temporary/asdf-test/cl-fad.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/cl-fad.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
cl-fad-0.4.3/
cl-fad-0.4.3/doc/
cl-fad-0.4.3/doc/index.html
cl-fad-0.4.3/CHANGELOG
cl-fad-0.4.3/README
cl-fad-0.4.3/cl-fad.asd
cl-fad-0.4.3/cl-fad.system
cl-fad-0.4.3/corman.lisp
cl-fad-0.4.3/fad.lisp
cl-fad-0.4.3/load.lisp
cl-fad-0.4.3/openmcl.lisp
cl-fad-0.4.3/packages.lisp
cl-fad-0.4.3/test.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-fad-0.4.3/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-fad-0.4.3/" 
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-fad-0.4.3/packages.lisp" (written 03 JAN 2006 01:44:32 PM):
; compiling (IN-PACKAGE #:CL-USER)
; compiling (DEFPACKAGE :CL-FAD ...)
; compiling (DEFPACKAGE :CL-FAD-TEST ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-fad-0.4.3/packages.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-fad-0.4.3/fad.lisp" (written 15 MAR 2006 04:37:14 AM):
; compiling (IN-PACKAGE :CL-FAD)
; compiling (DEFUN COMPONENT-PRESENT-P ...)
; compiling (DEFUN DIRECTORY-PATHNAME-P ...)
; compiling (DEFUN PATHNAME-AS-DIRECTORY ...)
; compiling (DEFUN DIRECTORY-WILDCARD ...)
; compiling (DEFUN LIST-DIRECTORY ...)
; compiling (DEFUN PATHNAME-AS-FILE ...)
; compiling (DEFUN FILE-EXISTS-P ...)
; compiling (DEFUN DIRECTORY-EXISTS-P ...)
; compiling (DEFUN WALK-DIRECTORY ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-fad-0.4.3/fad.lisp
; in: DEFUN WALK-DIRECTORY
;     (LET ((CL-FAD::*DIRECTORIES-SEEN* (MAKE-HASH-TABLE :TEST #'EQUAL)))
;     (LABELS ((CL-FAD::WALK (CL-FAD::NAME)
;                (LET #
;                  #)))
;       (LET ((CL-FAD:PATHNAME-AS-DIRECTORY #))
;         (CASE CL-FAD::IF-DOES-NOT-EXIST (# #) (# #) (OTHERWISE #)))
;       (VALUES)))
; 
; caught STYLE-WARNING:
;   using the lexical binding of the symbol *DIRECTORIES-SEEN*, not the
;   dynamic binding, even though the symbol name follows the usual naming
;   convention (names like *FOO*) for special variables

; compiling (DECLAIM (INLINE COPY-STREAM))
; compiling (DEFUN COPY-STREAM ...)
; compiling (DEFUN COPY-FILE ...)
; compiling (DEFUN DELETE-DIRECTORY-AND-FILES ...)
; compiling (PUSHNEW :CL-FAD ...)
; compiling (DEFVAR *HYPERDOC-BASE-URI* ...)
; compiling (LET (#) ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-fad-0.4.3/fad.fasl written
; compilation finished in 0:00:01
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {400080E1}> on
   #<CL-SOURCE-FILE "fad" {400080F1}>.
; 
; compilation unit finished
;   caught 1 STYLE-WARNING condition
;;; ASDF-INSTALL: Downloading package CL-HTML-PARSE, required by asdf-install-tester

;;; ASDF-INSTALL: Downloading 33098 bytes from http://common-lisp.net/project/cl-containers/cl-html-parse/cl-html-parse_latest.tar.gz to /Users/gwking/temporary/asdf-test/cl-html-parse.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/cl-html-parse.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
cl-html-parse/
cl-html-parse/cl-html-parse.asd
cl-html-parse/COPYING
cl-html-parse/dev/
cl-html-parse/dev/cl-html-parse.lisp
cl-html-parse/dev/cl-html-parse.system
cl-html-parse/dev/examples/
cl-html-parse/dev/examples/contacts.html
cl-html-parse/dev/htout.lisp
cl-html-parse/dev/if-star.lisp
cl-html-parse/dev/package.lisp
cl-html-parse/dev/README

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/" 
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/package.lisp" (written 04 APR 2006 09:26:32 AM):
; compiling (IN-PACKAGE :COMMON-LISP-USER)
; compiling (DEFPACKAGE :ACL-COMPAT.EXCL ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/if-star.lisp" (written 04 APR 2006 09:26:32 AM):
; compiling (IN-PACKAGE :ACL-COMPAT.EXCL)
; compiling (DEFVAR IF*-KEYWORD-LIST ...)
; compiling (DEFMACRO IF* ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/if-star.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp" (written 04 APR 2006 09:26:31 AM):
; compiling (DEFPACKAGE NET.HTML.PARSER ...)
; compiling (IN-PACKAGE :NET.HTML.PARSER)
; compiling (DEFUN CURRENT-CASE-MODE ...)
; compiling (DEFMACRO TAG-AUTO-CLOSE ...)
; compiling (DEFMACRO TAG-AUTO-CLOSE-STOP ...)
; compiling (DEFMACRO TAG-NO-END ...)
; compiling (DEFMACRO TAG-NO-PCDATA ...)
; compiling (DEFMACRO TAG-NAME ...)
; 
; caught STYLE-WARNING:
;   using deprecated EVAL-WHEN situation names EVAL LOAD COMPILE

; compiling (DEFCONSTANT STATE-PCDATA ...)
; compiling (DEFCONSTANT STATE-READTAGFIRST ...)
; compiling (DEFCONSTANT STATE-READTAG ...)
; compiling (DEFCONSTANT STATE-FINDATTRIBNAME ...)
; compiling (DEFCONSTANT STATE-ATTRIBNAME ...)
; compiling (DEFCONSTANT STATE-ATTRIBSTARTVALUE ...)
; compiling (DEFCONSTANT STATE-ATTRIBVALUEDELIM ...)
; compiling (DEFCONSTANT STATE-ATTRIBVALUENODELIM ...)
; compiling (DEFCONSTANT STATE-READCOMMENT ...)
; compiling (DEFCONSTANT STATE-READCOMMENT-ONE ...)
; compiling (DEFCONSTANT STATE-READCOMMENT-TWO ...)
; compiling (DEFCONSTANT STATE-FINDVALUE ...)
; compiling (DEFCONSTANT STATE-RAWDATA ...)
; compiling (DEFSTRUCT COLLECTOR ...)
; compiling (DEFPARAMETER *COLLECTORS* ...)
; compiling (DEFUN GET-COLLECTOR ...)
; compiling (DEFUN PUT-BACK-COLLECTOR ...)
; compiling (DEFUN GROW-AND-ADD ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFUN GROW-AND-ADD
;     (LENGTH NET.HTML.PARSER::ODATA)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MAKE-STRING (* 2 (LENGTH NET.HTML.PARSER::ODATA)))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the first argument of CHECK-FIXNUM

;     (SETF (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL)
;           (1+ NET.HTML.PARSER::NEXT))
; --> LET* MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {40BBFC71}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-154)
;                            1
;                            (THE T #:ONCE-ONLY-153))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

; compiling (DEFCONSTANT CHAR-TAGCHARACTER ...)
; compiling (DEFCONSTANT CHAR-ATTRIBNAMECHAR ...)
; compiling (DEFCONSTANT CHAR-ATTRIBUNDELIMATTRIBVALUE ...)
; compiling (DEFCONSTANT CHAR-SPACECHAR ...)
; compiling (DEFPARAMETER *CHARACTERISTICS* ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFPARAMETER *CHARACTERISTICS*
;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\:)
;                           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;                              NET.HTML.PARSER::CHAR-TAGCHARACTER))
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\:))
;           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;              NET.HTML.PARSER::CHAR-TAGCHARACTER))
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\_)
;                           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;                              NET.HTML.PARSER::CHAR-TAGCHARACTER))
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\_))
;           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;              NET.HTML.PARSER::CHAR-TAGCHARACTER))
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\-)
;                           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;                              NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE))
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\-))
;           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;              NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE))
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\.)
;                           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;                              NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE))
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\.))
;           (+ NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;              NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE))
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\:)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\:))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\@)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\@))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\/)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\/))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\!)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\!))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\#)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\#))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\$)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\$))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\%)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\%))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\^)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\^))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\&)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\&))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\()
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\())
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\))
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\)))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\_)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\_))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\=)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\=))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\+)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\+))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\\)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\\))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\|)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\|))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\{)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\{))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\})
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\}))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\[)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\[))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\])
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\]))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\;)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\;))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\')
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\'))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\")
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\"))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\,)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\,))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\<)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\<))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\?)
;                           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\?))
;           NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\-) NET.HTML.PARSER::CHAR-TAGCHARACTER)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\-))
;           NET.HTML.PARSER::CHAR-TAGCHARACTER)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\!) NET.HTML.PARSER::CHAR-TAGCHARACTER)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\!))
;           NET.HTML.PARSER::CHAR-TAGCHARACTER)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\ ) NET.HTML.PARSER::CHAR-SPACECHAR)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\ ))
;           NET.HTML.PARSER::CHAR-SPACECHAR)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\Tab) NET.HTML.PARSER::CHAR-SPACECHAR)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\Tab))
;           NET.HTML.PARSER::CHAR-SPACECHAR)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\Return) NET.HTML.PARSER::CHAR-SPACECHAR)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\Return))
;           NET.HTML.PARSER::CHAR-SPACECHAR)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT (CHAR-CODE #\Newline) NET.HTML.PARSER::CHAR-SPACECHAR)
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR (CHAR-CODE #\Newline))
;           NET.HTML.PARSER::CHAR-SPACECHAR)
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

;     (NET.HTML.PARSER::ADDIT NET.HTML.PARSER::I
;                           (+ NET.HTML.PARSER::CHAR-TAGCHARACTER
;                              NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;                              NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE))
; --> SETF SB-KERNEL:%SVSET SB-KERNEL:%ASET 
; ==>
;   (LOGIOR (SVREF NET.HTML.PARSER::ARR NET.HTML.PARSER::I)
;           (+ NET.HTML.PARSER::CHAR-TAGCHARACTER
;              NET.HTML.PARSER::CHAR-ATTRIBNAMECHAR
;              NET.HTML.PARSER::CHAR-ATTRIBUNDELIMATTRIBVALUE))
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.
; 
; note: forced to do static-fun Two-arg-ior (cost 53)
;       unable to do inline fixnum logical op (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 32) logical op (cost 2) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

; compiling (DEFUN CHAR-CHARACTERISTIC ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFUN CHAR-CHARACTERISTIC
;     (LOGAND (SVREF NET.HTML.PARSER::*CHARACTERISTICS* NET.HTML.PARSER::CODE) BIT)
; 
; note: forced to do static-fun Two-arg-and (cost 53)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 32) arithmetic (cost 3) because:
;       The first argument is a T, not a (SIGNED-BYTE 32).
;       The second argument is a T, not a (SIGNED-BYTE 32).
;       The result is a (VALUES INTEGER
;                               &OPTIONAL), not a (VALUES (SIGNED-BYTE 32)
;                                                         &REST
;                                                         T).
;       etc.

; compiling (DEFVAR *HTML-ENTITY-TO-CODE* ...)
; compiling (DEFSTRUCT TOKENBUF ...)
; compiling (DEFPARAMETER *TOKENBUFS* ...)
; compiling (DEFUN GET-TOKENBUF ...)
; compiling (DEFUN PUT-BACK-TOKENBUF ...)
; compiling (DEFUN TO-PREFERRED-CASE ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFUN TO-PREFERRED-CASE
;     (CHAR-UPCASE NET.HTML.PARSER::CH)
; ==>
;   NET.HTML.PARSER::CH
; 
; note: deleting unreachable code

; compiling (DEFUN NEXT-TOKEN ...); in: LAMBDA (#:WHOLE708 #:ENVIRONMENT709)
;     (LET* ((STREAM (CAR (CDR #:WHOLE708))))
;     (BLOCK NET.HTML.PARSER::NEXT-CHAR
;       '(LET ((NET.HTML.PARSER::CUR #) (NET.HTML.PARSER::TB #))
;          (ACL-COMPAT.EXCL:IF* (>= NET.HTML.PARSER::CUR #)
;                               NET.HTML.PARSER::THEN
;                               (ACL-COMPAT.EXCL:IF* #
;                                                    NET.HTML.PARSER::THEN
;                                                    #
;                                                    NET.HTML.PARSER::ELSE
;                                                    #))
;          (ACL-COMPAT.EXCL:IF* NET.HTML.PARSER::CUR
;                               NET.HTML.PARSER::THEN
;                               (PROG1 # #)))))
; 
; caught STYLE-WARNING:
;   The variable STREAM is defined but never used.
; in: LAMBDA (#:WHOLE710 #:ENVIRONMENT711)
;     (LET* ((STREAM (CAR (CDR #:WHOLE710))) (NET.HTML.PARSER::CH (CAR (CDR #))))
;     (BLOCK NET.HTML.PARSER::UN-NEXT-CHAR
;       '(DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))))
; 
; caught STYLE-WARNING:
;   The variable STREAM is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable CH is defined but never used.
; in: LAMBDA (#:WHOLE712 #:ENVIRONMENT713)
;     (LET* ((NET.HTML.PARSER::COLL (CAR (CDR #:WHOLE712))))
;     (BLOCK NET.HTML.PARSER::CLEAR-COLL
;       '(SETF (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL) 0)))
; 
; caught STYLE-WARNING:
;   The variable COLL is defined but never used.

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFUN NEXT-TOKEN
;     (>= NET.HTML.PARSER::CUR
;       (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; --> IF 
; ==>
;   (< NET.HTML.PARSER::CUR
;      (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (FUNCALL NET.HTML.PARSER::READ-SEQUENCE-FUNC NET.HTML.PARSER::TB STREAM)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

;     (ZEROP
;    (SETF (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF)
;            (ACL-COMPAT.EXCL:IF* NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                 NET.HTML.PARSER::THEN
;                                 (FUNCALL NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                          NET.HTML.PARSER::TB
;                                          STREAM)
;                                 NET.HTML.PARSER::ELSE
;                                 (READ-SEQUENCE NET.HTML.PARSER::TB STREAM))))
; ==>
;   (=
;    (SETF (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF)
;            (ACL-COMPAT.EXCL:IF* NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                 NET.HTML.PARSER::THEN
;                                 (FUNCALL NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                          NET.HTML.PARSER::TB
;                                          STREAM)
;                                 NET.HTML.PARSER::ELSE
;                                 (READ-SEQUENCE NET.HTML.PARSER::TB STREAM)))
;    0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (> (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G728) #:G729)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (>= NET.HTML.PARSER::CUR
;       (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; --> IF 
; ==>
;   (< NET.HTML.PARSER::CUR
;      (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (FUNCALL NET.HTML.PARSER::READ-SEQUENCE-FUNC NET.HTML.PARSER::TB STREAM)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

;     (ZEROP
;    (SETF (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF)
;            (ACL-COMPAT.EXCL:IF* NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                 NET.HTML.PARSER::THEN
;                                 (FUNCALL NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                          NET.HTML.PARSER::TB
;                                          STREAM)
;                                 NET.HTML.PARSER::ELSE
;                                 (READ-SEQUENCE NET.HTML.PARSER::TB STREAM))))
; ==>
;   (=
;    (SETF (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF)
;            (ACL-COMPAT.EXCL:IF* NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                 NET.HTML.PARSER::THEN
;                                 (FUNCALL NET.HTML.PARSER::READ-SEQUENCE-FUNC
;                                          NET.HTML.PARSER::TB
;                                          STREAM)
;                                 NET.HTML.PARSER::ELSE
;                                 (READ-SEQUENCE NET.HTML.PARSER::TB STREAM)))
;    0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (* 10 COUNT)
; ==>
;   (* SB-C::Y 10)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to
;   convert x*2^k to shift
; due to type uncertainty:
;   The first argument is a NUMBER, not a INTEGER.
; 
; note: unable to
;   recode as shifts and adds
; due to type uncertainty:
;   The first argument is a NUMBER, not a (UNSIGNED-BYTE 32).
;   The result is a (VALUES NUMBER
;                           &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 32) &REST T).

;     (+ (* 10 COUNT) (- NET.HTML.PARSER::CODE 48))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL (CODE-CHAR COUNT))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (CODE-CHAR NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G773) #:G774)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (NET.HTML.PARSER::TO-PREFERRED-CASE
;                                  NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (INCF NET.HTML.PARSER::NAME-LENGTH)
; --> LET* 
; ==>
;   (+ NET.HTML.PARSER::NAME-LENGTH #:G785)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G795) #:G796)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G800) #:G801)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G809) #:G810)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G819) #:G820)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G824) #:G825)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (NET.HTML.PARSER::TO-PREFERRED-CASE
;                                  NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G848) #:G849)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G854) #:G855)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G881) #:G882)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL #\-)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL #\-)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (ELT NET.HTML.PARSER::RAW-MODE-DELIMITER NET.HTML.PARSER::RAW-LENGTH)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

;     (LENGTH NET.HTML.PARSER::RAW-MODE-DELIMITER)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (ZEROP (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL))
; ==>
;   (= (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL) 0)
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (ELT NET.HTML.PARSER::RAW-MODE-DELIMITER
;                                      NET.HTML.PARSER::I))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (ELT NET.HTML.PARSER::RAW-MODE-DELIMITER NET.HTML.PARSER::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a SINGLE-FLOAT.
;   The second argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a REAL, not a DOUBLE-FLOAT.
;   The second argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to
;   open-code FLOAT to RATIONAL comparison
; due to type uncertainty:
;   The first argument is a REAL, not a FLOAT.
;   The second argument is a REAL, not a RATIONAL.

;     (>= NET.HTML.PARSER::CUR
;       (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; --> IF 
; ==>
;   (< NET.HTML.PARSER::CUR
;      (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (> (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL) 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G728) #:G729)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (>= NET.HTML.PARSER::CUR
;       (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; --> IF 
; ==>
;   (< NET.HTML.PARSER::CUR
;      (NET.HTML.PARSER::TOKENBUF-MAX NET.HTML.PARSER::TOKENBUF))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (* 10 COUNT)
; ==>
;   (* SB-C::Y 10)
; 
; note: forced to do GENERIC-* (cost 50)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (+ (* 10 COUNT) (- NET.HTML.PARSER::CODE 48))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do safe inline fixnum arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL (CODE-CHAR COUNT))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (CODE-CHAR NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (DECF MAX)
; --> LET* 
; ==>
;   (- MAX #:G734)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 10), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 9)
;                               &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 10), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 9)
;                               &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G773) #:G774)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (NET.HTML.PARSER::TO-PREFERRED-CASE
;                                  NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (INCF NET.HTML.PARSER::NAME-LENGTH)
; --> LET* 
; ==>
;   (+ NET.HTML.PARSER::NAME-LENGTH #:G785)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G795) #:G796)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G800) #:G801)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G809) #:G810)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G819) #:G820)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G824) #:G825)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (NET.HTML.PARSER::TO-PREFERRED-CASE
;                                  NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G848) #:G849)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G854) #:G855)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (DECF (NET.HTML.PARSER::TOKENBUF-CUR NET.HTML.PARSER::TOKENBUF))
; --> LET* 
; ==>
;   (- (NET.HTML.PARSER::TOKENBUF-CUR #:G881) #:G882)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL #\-)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL #\-)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (ELT NET.HTML.PARSER::RAW-MODE-DELIMITER
;                                      NET.HTML.PARSER::I))
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF >= IF 
; ==>
;   (< NET.HTML.PARSER::.NEXT.
;      (NET.HTML.PARSER::COLLECTOR-MAX NET.HTML.PARSER::COLL))
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (ELT NET.HTML.PARSER::RAW-MODE-DELIMITER
;                                      NET.HTML.PARSER::I))
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-971)
;                            1
;                            (THE T #:ONCE-ONLY-970))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-979)
;                            1
;                            (THE T #:ONCE-ONLY-978))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL #\-)
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-927)
;                            1
;                            (THE T #:ONCE-ONLY-926))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-934)
;                            1
;                            (THE T #:ONCE-ONLY-933))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-920)
;                            1
;                            (THE T #:ONCE-ONLY-919))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-899)
;                            1
;                            (THE T #:ONCE-ONLY-898))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-879)
;                            1
;                            (THE T #:ONCE-ONLY-878))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-872)
;                            1
;                            (THE T #:ONCE-ONLY-871))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (NET.HTML.PARSER::TO-PREFERRED-CASE
;                                  NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-834)
;                            1
;                            (THE T #:ONCE-ONLY-833))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-783)
;                            1
;                            (THE T #:ONCE-ONLY-782))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-771)
;                            1
;                            (THE T #:ONCE-ONLY-770))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL
;                                 (CODE-CHAR NET.HTML.PARSER::CH))
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-764)
;                            1
;                            (THE T #:ONCE-ONLY-763))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL (CODE-CHAR COUNT))
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-757)
;                            1
;                            (THE T #:ONCE-ONLY-756))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL #\-)
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-906)
;                            1
;                            (THE T #:ONCE-ONLY-905))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

;     (NET.HTML.PARSER::ADD-TO-COLL NET.HTML.PARSER::COLL NET.HTML.PARSER::CH)
; --> LET ACL-COMPAT.EXCL:IF* COND IF COND IF PROGN SETF LET* 
; --> MULTIPLE-VALUE-BIND LET FUNCALL SB-C::%FUNCALL 
; --> #<SB-C::GLOBAL-VAR :%SOURCE-NAME (SETF NET.HTML.PARSER::COLLECTOR-NEXT) :TYPE #<SB-KERNEL:FUN-TYPE (FUNCTION (T NET.HTML.PARSER::COLLECTOR) (VALUES T &OPTIONAL))> :WHERE-FROM :DECLARED :KIND :GLOBAL-FUNCTION {4010EFF1}> 
; --> LET LET 
; ==>
;   (SB-KERNEL:%INSTANCE-SET (THE NET.HTML.PARSER::COLLECTOR #:ONCE-ONLY-913)
;                            1
;                            (THE T #:ONCE-ONLY-912))
; 
; note: doing signed word to integer coercion (cost 20), for:
;       the third argument of INSTANCE-INDEX-SET

; compiling (DEFVAR *KWD-PACKAGE* ...)
; compiling (DEFUN COMPUTE-TAG ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFUN COMPUTE-TAG
;     (SUBSEQ (NET.HTML.PARSER::COLLECTOR-DATA NET.HTML.PARSER::COLL)
;           0
;           (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BASE-STRING &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY CHARACTER (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY SINGLE-FLOAT (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY SINGLE-FLOAT (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a SIMPLE-BIT-VECTOR.
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES SIMPLE-BIT-VECTOR &REST T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 2)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 4)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 7)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 8)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 15)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 29) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 29)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 31)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (UNSIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 8) (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 16)
;                                                            (*))
;                                              &REST
;                                              T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY FIXNUM (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES (SIMPLE-ARRAY FIXNUM (*))
;                                                     &REST
;                                                     T).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)).
;   The result is a (VALUES (OR CONS NULL (SIMPLE-ARRAY * (*)))
;                           &OPTIONAL), not a (VALUES
;                                              (SIMPLE-ARRAY (SIGNED-BYTE 32)
;                                                            (*))
;                                              &REST
;                                              T).

; compiling (DEFUN COMPUTE-COLL-STRING ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFUN COMPUTE-COLL-STRING
;     (DOTIMES
;       (NET.HTML.PARSER::I
;        (NET.HTML.PARSER::COLLECTOR-NEXT NET.HTML.PARSER::COLL))
;     (SETF (SCHAR NET.HTML.PARSER::STR NET.HTML.PARSER::I)
;             (SCHAR NET.HTML.PARSER::FROM NET.HTML.PARSER::I)))
; --> DO BLOCK LET TAGBODY UNLESS COND IF NOT IF >= IF 
; ==>
;   (< NET.HTML.PARSER::I #:G1014)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

; compiling (DEFUN COLL-HAS-COMMENT ...)
; compiling (DOLIST (OPT #) ...)
; compiling (DEFVAR *IN-LINE* ...)
; compiling (DEFVAR *CH-FORMAT* ...)
; compiling (DEFVAR *KNOWN-TAGS* ...)
; compiling (SETF (TAG-AUTO-CLOSE :TR) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :TR) ...)
; compiling (SETF (TAG-AUTO-CLOSE :TD) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :TD) ...)
; compiling (SETF (TAG-AUTO-CLOSE :TH) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :TH) ...)
; compiling (SETF (TAG-AUTO-CLOSE :DT) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :DT) ...)
; compiling (SETF (TAG-AUTO-CLOSE :LI) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :LI) ...)
; compiling (SETF (TAG-AUTO-CLOSE :ADDRESS) ...)
; compiling (SETF (TAG-AUTO-CLOSE :BLOCKQUOTE) ...)
; compiling (SETF (TAG-AUTO-CLOSE :BODY) ...)
; compiling (SETF (TAG-AUTO-CLOSE :DD) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :DD) ...)
; compiling (SETF (TAG-AUTO-CLOSE :DL) ...)
; compiling (SETF (TAG-AUTO-CLOSE :DIV) ...)
; compiling (SETF (TAG-AUTO-CLOSE :FIELDSET) ...)
; compiling (SETF (TAG-AUTO-CLOSE :FORM) ...)
; compiling (SETF (TAG-AUTO-CLOSE :FRAMESET) ...)
; compiling (SETF (TAG-AUTO-CLOSE :HR) ...)
; compiling (SETF (TAG-AUTO-CLOSE :H1) ...)
; compiling (SETF (TAG-AUTO-CLOSE :H2) ...)
; compiling (SETF (TAG-AUTO-CLOSE :H3) ...)
; compiling (SETF (TAG-AUTO-CLOSE :H4) ...)
; compiling (SETF (TAG-AUTO-CLOSE :H5) ...)
; compiling (SETF (TAG-AUTO-CLOSE :H6) ...)
; compiling (SETF (TAG-AUTO-CLOSE :NOSCRIPT) ...)
; compiling (SETF (TAG-AUTO-CLOSE :OL) ...)
; compiling (SETF (TAG-AUTO-CLOSE :OPTION) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :OPTION) ...)
; compiling (SETF (TAG-AUTO-CLOSE :P) ...)
; compiling (SETF (TAG-AUTO-CLOSE :PRE) ...)
; compiling (SETF (TAG-AUTO-CLOSE :TABLE) ...)
; compiling (SETF (TAG-AUTO-CLOSE :TBODY) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :TBODY) ...)
; compiling (SETF (TAG-AUTO-CLOSE :TFOOT) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :TFOOT) ...)
; compiling (SETF (TAG-AUTO-CLOSE :THEAD) ...)
; compiling (SETF (TAG-AUTO-CLOSE-STOP :THEAD) ...)
; compiling (SETF (TAG-AUTO-CLOSE :UL) ...)
; compiling (SETF (TAG-NO-PCDATA :TABLE) ...)
; compiling (SETF (TAG-NO-PCDATA :TR) ...)
; compiling (DEFMETHOD PARSE-HTML ...)
; compiling (DEFMACRO TAG-CALLBACK ...)
; compiling (DEFUN PHTML-INTERNAL ...)

; file: /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.lisp
; in: DEFUN PHTML-INTERNAL
;     (ACL-COMPAT.EXCL:IF*
;    (EQ (NET.HTML.PARSER::CURRENT-CASE-MODE) :CASE-INSENSITIVE-UPPER)
;    NET.HTML.PARSER::THEN
;    "</STYLE>"
;    NET.HTML.PARSER::ELSE
;    "</style>")
; --> COND IF PROGN 
; ==>
;   "</STYLE>"
; 
; note: deleting unreachable code

;     (ACL-COMPAT.EXCL:IF*
;    (EQ (NET.HTML.PARSER::CURRENT-CASE-MODE) :CASE-INSENSITIVE-UPPER)
;    NET.HTML.PARSER::THEN
;    "</SCRIPT>"
;    NET.HTML.PARSER::ELSE
;    "</script>")
; --> COND IF PROGN 
; ==>
;   "</SCRIPT>"
; 
; note: deleting unreachable code

;     (NET.HTML.PARSER::TAG-CALLBACK
;    (NET.HTML.PARSER::TAG-NAME NET.HTML.PARSER::CURRENT-TAG))
; --> REST CDR 
; ==>
;   (ASSOC (NET.HTML.PARSER::TAG-NAME NET.HTML.PARSER::CURRENT-TAG)
;          NET.HTML.PARSER::CALLBACKS)
; 
; note: unable to convert to EQ test because: Item might be a number.

;     (FUNCALL NET.HTML.PARSER::CALLBACK NET.HTML.PARSER::ELEMENT)
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

;     (LENGTH (NET.HTML.PARSER::TOKENBUF-FIRST-PASS NET.HTML.PARSER::TOKENBUF))
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (MEMBER NET.HTML.PARSER::LAST-TAG NET.HTML.PARSER::*IN-LINE*)
; 
; note: unable to convert to EQ test because: Item might be a number.

;     (LENGTH NET.HTML.PARSER::VAL)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a VECTOR.

;     (ELT NET.HTML.PARSER::VAL NET.HTML.PARSER::I)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a SEQUENCE, not a LIST.

;     (LENGTH NET.HTML.PARSER::RAW-MODE-DELIMITER)
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY CHARACTER (1))
;                               (SIMPLE-ARRAY CHARACTER (8))
;                               (SIMPLE-ARRAY CHARACTER (9))
;                               NULL), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to
;   optimize
; due to type uncertainty:
;   The first argument is a (OR (SIMPLE-ARRAY CHARACTER (1))
;                               (SIMPLE-ARRAY CHARACTER (8))
;                               (SIMPLE-ARRAY CHARACTER (9))
;                               NULL), not a VECTOR.

;     (NET.HTML.PARSER::TAG-CALLBACK NET.HTML.PARSER::NAME)
; --> REST CDR 
; ==>
;   (ASSOC NET.HTML.PARSER::NAME NET.HTML.PARSER::CALLBACKS)
; 
; note: unable to convert to EQ test because: Item might be a number.

;     (NET.HTML.PARSER::TAG-CALLBACK
;    (NET.HTML.PARSER::TAG-NAME
;     (ACL-COMPAT.EXCL:IF* (ATOM NET.HTML.PARSER::VAL)
;                          NET.HTML.PARSER::THEN
;                          NET.HTML.PARSER::VAL
;                          NET.HTML.PARSER::ELSE
;                          (FIRST NET.HTML.PARSER::VAL))))
; --> REST CDR 
; ==>
;   (ASSOC
;    (NET.HTML.PARSER::TAG-NAME
;     (ACL-COMPAT.EXCL:IF* (ATOM NET.HTML.PARSER::VAL)
;                          NET.HTML.PARSER::THEN
;                          NET.HTML.PARSER::VAL
;                          NET.HTML.PARSER::ELSE
;                          (FIRST NET.HTML.PARSER::VAL)))
;    NET.HTML.PARSER::CALLBACKS)
; 
; note: unable to convert to EQ test because: Item might be a number.

;     (FUNCALL NET.HTML.PARSER::CALLBACK
;            (ACL-COMPAT.EXCL:IF* (ATOM NET.HTML.PARSER::VAL)
;                                 NET.HTML.PARSER::THEN
;                                 NET.HTML.PARSER::VAL
;                                 NET.HTML.PARSER::ELSE
;                                 (LIST NET.HTML.PARSER::VAL)))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-TO-FUN FUNCTION)
; 
; note: unable to
;   optimize away possible call to FDEFINITION at runtime
; due to type uncertainty:
;   The first argument is a (OR FUNCTION SYMBOL), not a FUNCTION.

;     (MEMBER (NET.HTML.PARSER::TAG-NAME NET.HTML.PARSER::CURRENT-TAG)
;           NET.HTML.PARSER::*KNOWN-TAGS*)
; 
; note: unable to convert to EQ test because: Item might be a number.

;     (MEMBER (NET.HTML.PARSER::TAG-NAME NET.HTML.PARSER::CURRENT-TAG)
;           NET.HTML.PARSER::*CH-FORMAT*)
; 
; note: unable to convert to EQ test because: Item might be a number.

;     (MEMBER (NET.HTML.PARSER::TAG-NAME NET.HTML.PARSER::CURRENT-TAG)
;           NET.HTML.PARSER::*KNOWN-TAGS*)
; 
; note: unable to convert to EQ test because: Item might be a number.

; compiling (DEFMETHOD PARSE-HTML ...)
; compiling (DEFMETHOD PARSE-HTML ...)
; compiling (PROVIDE :PHTML)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/cl-html-parse/dev/cl-html-parse.fasl written
; compilation finished in 0:00:04
WARNING:
   COMPILE-FILE warned while performing #<COMPILE-OP NIL {10007F81}> on
   #<CL-SOURCE-FILE "cl-html-parse" {10007F91}>.
STYLE-WARNING: implicitly creating new generic function PARSE-HTML
; 
; compilation unit finished
;   caught 5 STYLE-WARNING conditions
;   printed 248 notes
;;; ASDF-INSTALL: Downloading package TRIVIAL-HTTP, required by asdf-install-tester

;;; ASDF-INSTALL: Downloading 3427 bytes from http://www.unmutual.info/software/trivial-http-1.1.tar.gz to /Users/gwking/temporary/asdf-test/trivial-http.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/trivial-http.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
trivial-http-1.1/
trivial-http-1.1/.svn/
trivial-http-1.1/.svn/README.txt
trivial-http-1.1/.svn/empty-file
trivial-http-1.1/.svn/entries
trivial-http-1.1/.svn/format
trivial-http-1.1/.svn/prop-base/
trivial-http-1.1/.svn/prop-base/LICENSE.svn-base
trivial-http-1.1/.svn/prop-base/README.svn-base
trivial-http-1.1/.svn/prop-base/trivial-http.asd.svn-base
trivial-http-1.1/.svn/prop-base/trivial-http.lisp.svn-base
trivial-http-1.1/.svn/props/
trivial-http-1.1/.svn/props/LICENSE.svn-work
trivial-http-1.1/.svn/props/README.svn-work
trivial-http-1.1/.svn/props/trivial-http.asd.svn-work
trivial-http-1.1/.svn/props/trivial-http.lisp.svn-work
trivial-http-1.1/.svn/text-base/
trivial-http-1.1/.svn/text-base/LICENSE.svn-base
trivial-http-1.1/.svn/text-base/README.svn-base
trivial-http-1.1/.svn/text-base/trivial-http.asd.svn-base
trivial-http-1.1/.svn/text-base/trivial-http.lisp.svn-base
trivial-http-1.1/.svn/tmp/
trivial-http-1.1/.svn/tmp/prop-base/
trivial-http-1.1/.svn/tmp/props/
trivial-http-1.1/.svn/tmp/text-base/
trivial-http-1.1/.svn/tmp/wcprops/
trivial-http-1.1/.svn/wcprops/
trivial-http-1.1/LICENSE
trivial-http-1.1/README
trivial-http-1.1/trivial-http.asd
trivial-http-1.1/trivial-http.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-http-1.1/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-http-1.1/" ;;; ASDF-INSTALL: Downloading package TRIVIAL-SOCKETS, required by trivial-http

;;; ASDF-INSTALL: Downloading 9714 bytes from http://ftp.linux.org.uk/pub/lisp/cclan/trivial-sockets.tar.gz to /Users/gwking/temporary/asdf-test/trivial-sockets.asdf-install-tmp ...

;;; ASDF-INSTALL: Installing /Users/gwking/temporary/asdf-test/trivial-sockets.asdf-install-tmp in /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/, /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site-systems/
trivial-sockets_0.3/
trivial-sockets_0.3/README
trivial-sockets_0.3/trivial-sockets.asd
trivial-sockets_0.3/trivial-sockets.texi
trivial-sockets_0.3/sbcl.lisp
trivial-sockets_0.3/cmucl.lisp
trivial-sockets_0.3/defpackage.lisp
trivial-sockets_0.3/clisp.lisp
trivial-sockets_0.3/allegro.lisp
trivial-sockets_0.3/errors.lisp
trivial-sockets_0.3/openmcl.lisp
trivial-sockets_0.3/server.lisp
trivial-sockets_0.3/lispworks.lisp
trivial-sockets_0.3/abcl.lisp

#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/" 
#P"/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/" 
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/defpackage.lisp" (written 20 OCT 2005 05:12:17 PM):
; compiling (IN-PACKAGE :CL-USER)
; compiling (DEFPACKAGE TRIVIAL-SOCKETS ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/defpackage.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/errors.lisp" (written 20 OCT 2005 05:12:17 PM):
; compiling (IN-PACKAGE :TRIVIAL-SOCKETS)
; compiling (DEFINE-CONDITION UNSUPPORTED ...)
; compiling (DEFINE-CONDITION SOCKET-ERROR ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/errors.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/sbcl.lisp" (written 20 OCT 2005 05:12:17 PM):
; compiling (IN-PACKAGE :TRIVIAL-SOCKETS)
; compiling (DEFUN RESOLVE-HOSTNAME ...)
; compiling (DEFUN OPEN-STREAM ...)
; compiling (DEFUN OPEN-SERVER ...)
; compiling (DEFUN CLOSE-SERVER ...)
; compiling (DEFUN ACCEPT-CONNECTION ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/sbcl.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/server.lisp" (written 20 OCT 2005 05:12:17 PM):
; compiling (IN-PACKAGE :TRIVIAL-SOCKETS)
; compiling (DEFMACRO WITH-SERVER ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-sockets_0.3/server.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-http-1.1/trivial-http.lisp" (written 17 JAN 2006 11:29:57 AM):
; compiling (DEFPACKAGE :TRIVIAL-HTTP ...)
; compiling (IN-PACKAGE :TRIVIAL-HTTP)
; compiling (DEFUN URL-PORT ...)
; compiling (DEFUN URL-HOST ...)
; compiling (DEFCONSTANT +CRLF+ ...)
; compiling (DEFUN RESPONSE-READ-CODE ...)
; compiling (DEFUN RESPONSE-READ-HEADERS ...)
; compiling (DEFUN HTTP-GET ...)
; compiling (DEFUN HTTP-POST ...)
; compiling (DEFUN URL-RESERVED-CHARACTER-P ...)
; compiling (DEFUN ESCAPE-URL-QUERY ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/trivial-http-1.1/trivial-http.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/package.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE COMMON-LISP-USER)
; compiling (DEFPACKAGE #:ASDF-INSTALL-TESTER ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/package.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/lisp-implementation.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (DEFPACKAGE "LISP-IMPLEMENTATION" ...)
; compiling (IN-PACKAGE LISP-IMPLEMENTATION)
; compiling (DEFPARAMETER *IMPLEMENTATION-FEATURES* ...)
; compiling (DEFPARAMETER *OS-FEATURES* ...)
; compiling (DEFPARAMETER *ARCHITECTURE-FEATURES* ...)
; compiling (DEFUN LISP-VERSION-STRING ...)
; compiling (DEFUN FIRST-IN-FEATURES ...)
; compiling (DEFUN FIRST-IMPLEMENTATION ...)
; compiling (DEFUN FIRST-OS ...)
; compiling (DEFUN FIRST-ARCHITECTURE ...)
; compiling (DEFUN IMPLEMENTATION-SPECIFIC-SHORTHAND ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/lisp-implementation.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/definitions.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFINE-CONDITION TIMEOUT-ERROR ...)
; compiling (DEFVAR *ASDF-INSTALL-TESTER-DIRECTORY* ...)
; compiling (DEFVAR *ASDF-INSTALL-DIRECTORY* ...)
; compiling (DEFVAR *ASDF-DIRECTORY* ...)
; compiling (DEFPARAMETER *WORKING-DIRECTORY* ...)
; compiling (DEFPARAMETER *MESSAGE-TYPE* ...)
; compiling (DEFPARAMETER *TIMEOUT* ...)
; compiling (DEFPARAMETER *CLIKI-PACKAGES-URL* ...)
; compiling (DEFPARAMETER *SYSTEMS-TO-REMOVE-EACH-TIME* ...)
; compiling (DEFPARAMETER *SYSTEMS-TO-TEST* ...)
; compiling (DEFPARAMETER *METABANG-SYSTEMS* ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/definitions.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/implementation.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFGENERIC IMPLEMENTATION-SPECIFIC-QUIT ...)
; compiling (DEFGENERIC MAKE-START-LISP-FOR-TEST-COMMAND ...)
; compiling (DEFMETHOD MAKE-START-LISP-FOR-TEST-COMMAND ...)
; compiling (DEFGENERIC IMPLEMENTATION-SPECIFIC-ASDF-LOADER ...)
; compiling (DEFMETHOD IMPLEMENTATION-SPECIFIC-ASDF-LOADER ...)
; compiling (DEFUN SHELL-COMMAND ...)
; compiling (DEFUN DELETE-DIRECTORY ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/implementation.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/http-download.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (DEFPACKAGE TRIVIAL-HTTP-DOWNLOAD ...)
; compiling (IN-PACKAGE TRIVIAL-HTTP-DOWNLOAD)
; compiling (DEFINE-CONDITION DOWNLOAD-ERROR ...)
; compiling (DEFUN HTTP-RESOLVE ...)
; compiling (DEFUN HTTP-DOWNLOAD ...)
; compiling (DECLAIM (INLINE COPY-STREAM))
; compiling (DEFUN COPY-STREAM ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/http-download.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/utilities.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFUN LATEST-FILE-DATE ...)
; compiling (DEFUN LATEST-SOURCE-FILE-DATE ...)
; compiling (DEFUN REMOVE-BINARY-FILES-FOR-CURRENT-LISP ...)
; compiling (DEFUN REMOVE-NON-LISP-FILES-FROM-ASDF-INSTALL-DIRECTORY ...)
; compiling (DEFUN PROBABLY-A-SOURCE-FILE-P ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/utilities.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/update-asdf-packages.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFUN ASDF-PACKAGES-LIST ...)
; compiling (DEFUN URL->LML ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/update-asdf-packages.fasl written
; compilation finished in 0:00:00
STYLE-WARNING: redefining LISP-VERSION-STRING in DEFUN
STYLE-WARNING: redefining FIRST-IN-FEATURES in DEFUN
STYLE-WARNING: redefining FIRST-IMPLEMENTATION in DEFUN
STYLE-WARNING: redefining FIRST-OS in DEFUN
STYLE-WARNING: redefining FIRST-ARCHITECTURE in DEFUN
STYLE-WARNING: redefining IMPLEMENTATION-SPECIFIC-SHORTHAND in DEFUN
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/main.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFUN REMOVE-SYSTEMS ...)
; compiling (DEFUN REMOVE-1-SYSTEM ...)
; compiling (DEFUN ASDF-TEST ...)
; compiling (DEFUN TEST-SYSTEM ...)
; compiling (DEFUN ENSURE-STRING ...)
; compiling (DEFUN FIX-STRING ...)
; compiling (DEFUN MAKE-WORKING-PATHNAME ...)
; compiling (DEFUN DATE/TIME->STRING ...)
; compiling (DEFUN TRY-TO-INSTALL ...)
; compiling (DEFUN REMOVE-STATUS-FILE ...)
; compiling (DEFUN WRITE-STATUS-PROPERTY ...)
; compiling (DEFUN WRITE-STATUS-MESSAGE ...)
; compiling (DEFUN DOCUMENT-SYSTEM-WITH-TINAA ...)
; compiling (DEFUN MAKE-STARTUP-FILE ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/main.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/system-extraction.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFPARAMETER *KNOWN-LICENCE-TYPES* ...)
; compiling (DEFPARAMETER *RELEASE-STATUS* ...)
; compiling (DEFPARAMETER *ACTIVITY* ...)
; compiling (DEFPARAMETER *PROJECT-SIZE* ...)
; compiling (DEFPARAMETER *PACKAGING* ...)
; compiling (DEFPARAMETER *L3-LIBRARIAN* ...)
; compiling (DEFPARAMETER *FIELDS* ...)
; compiling (DEFUN PUBLIC-FIELDS ...)
; compiling (DEFUN PUBLIC-P ...)
; compiling (DEFGENERIC FIND-DEFSYSTEM ...)
; compiling (DEFMETHOD FIND-DEFSYSTEM ...)
; compiling (DEFMETHOD FIND-DEFSYSTEM ...)
; compiling (DEFMETHOD FIND-DEFSYSTEM ...)
; compiling (DEFUN WRITE-OUT-SYSTEM-PROPERTIES ...)
; compiling (DEFUN FIND-LATEST-SYSTEM-FILE-DATE ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/system-extraction.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/allegro.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFMETHOD IMPLEMENTATION-SPECIFIC-QUIT ...)
; compiling (DEFMETHOD MAKE-START-LISP-FOR-TEST-COMMAND ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/allegro.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/clisp.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFMETHOD IMPLEMENTATION-SPECIFIC-QUIT ...)
; compiling (DEFMETHOD MAKE-START-LISP-FOR-TEST-COMMAND ...)
; compiling (DEFMETHOD IMPLEMENTATION-SPECIFIC-ASDF-LOADER ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/clisp.fasl written
; compilation finished in 0:00:01
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/openmcl.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFMETHOD IMPLEMENTATION-SPECIFIC-QUIT ...)
; compiling (DEFMETHOD MAKE-START-LISP-FOR-TEST-COMMAND ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/openmcl.fasl written
; compilation finished in 0:00:00
; compiling file "/Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/sbcl.lisp" (written 04 APR 2006 09:25:56 AM):
; compiling (IN-PACKAGE ASDF-INSTALL-TESTER)
; compiling (DEFMETHOD IMPLEMENTATION-SPECIFIC-QUIT ...)
; compiling (DEFMETHOD MAKE-START-LISP-FOR-TEST-COMMAND ...)

; /Users/gwking/temporary/asdf-test/input/sbcl0-9-9/site/ait/dev/sbcl.fasl written
; compilation finished in 0:00:00