hyperobject

SBCL 2.0.5.91-ada264956 / ASDF 3.3.1

hyperobject

WARNING: UIOP/VERSION:PARSE-VERSION: "2.7.x" doesn't follow asdf version numbering convention
WARNING: Invalid :version specifier "2.7.x" for component "hyperobject" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/hyperobject/da930ff34d7d234a1ae6e7c7596f0f5810106a3f/hyperobject-20200624-git/hyperobject.asd", using NIL instead
WARNING: Invalid :version specifier "2.7.x" for component "hyperobject" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/hyperobject/da930ff34d7d234a1ae6e7c7596f0f5810106a3f/hyperobject-20200624-git/hyperobject.asd", using NIL instead
; 
; caught ERROR:
;   READ error during COMPILE-FILE: The symbol "SLOT-DEFINITION-NAME" is not external in the SB-PCL package. Line: 94, Column: 32, File-Position: 3190 Stream: #<SB-INT:FORM-TRACKING-STREAM for "file /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/mop.lisp" {100610CC03}>
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1000A30083}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "kmrcl" "mop">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1000A30083}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1006261283}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1006261283}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1006261283}>)
3: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">)))
4: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">)
6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
7: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {100525E0F3}>) [fast-method]
9: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
10: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {100525E0F3}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "hyperobject"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
12: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "hyperobject">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "hyperobject">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "hyperobject")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "hyperobject") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10052571AB}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005211EAB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "hyperobject") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "hyperobject" "hyperobject")
23: (DEPCHECK::MAGIC "hyperobject" "hyperobject" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-05MnFNoY/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "hyperobject" "hyperobject" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-05MnFNoY/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-05MnFNoY/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-14" :IN SAVE-LISP-AND-DIE))
28: ((LABELS SB-IMPL::RESTART-LISP :IN SAVE-LISP-AND-DIE))

unhandled condition in --disable-debugger mode, quitting
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions
;   caught 1 ERROR condition

hyperobject-tests

WARNING: UIOP/VERSION:PARSE-VERSION: "2.7.x" doesn't follow asdf version numbering convention
WARNING: Invalid :version specifier "2.7.x" for component "hyperobject" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/hyperobject/da930ff34d7d234a1ae6e7c7596f0f5810106a3f/hyperobject-20200624-git/hyperobject.asd", using NIL instead
WARNING: Invalid :version specifier "2.7.x" for component "hyperobject" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/hyperobject/da930ff34d7d234a1ae6e7c7596f0f5810106a3f/hyperobject-20200624-git/hyperobject.asd", using NIL instead

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/macros.lisp
; in: DEFMACRO PRINT-FORM-AND-RESULTS
;     (LET ((KMRCL::R (GENSYM "RES-")))
;       `(LET ((KMRCL::R ,KMRCL::FORM))
;          (FORMAT T "~&~A --> ~S~%" ',KMRCL::FORM KMRCL::R)
;          KMRCL::R))
; 
; caught STYLE-WARNING:
;   The variable R is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/macros.lisp
; in: DEFMACRO PRINT-FORM-AND-RESULTS
;     (LET ((KMRCL::R (GENSYM "RES-")))
;       `(LET ((KMRCL::R ,KMRCL::FORM))
;          (FORMAT T "~&~A --> ~S~%" ',KMRCL::FORM KMRCL::R)
;          KMRCL::R))
; 
; caught STYLE-WARNING:
;   The variable R is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "kmrcl" "macros">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/io.lisp
; in: DEFUN STREAM-SUBST
;     (KMRCL::BUF-FLUSH KMRCL::BUF KMRCL::OUT)
; ==>
;   KMRCL::BUF
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/io.lisp
; in: DEFUN DIRECTORY-TREE
;     (ERROR "~A" KMRCL::SUBDIRS)
; ==>
;   "~A"
; 
; note: deleting unreachable code

;     (ERROR "~A" KMRCL::ROOT)
; ==>
;   "~A"
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/io.lisp
; in: MAKE-UNSIGNED-INT-IO-FN 8
;     (KMRCL:MAKE-UNSIGNED-INT-IO-FN 8)
; --> PROGN KMRCL:DEF-UNSIGNED-INT-IO EVAL-WHEN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA KMRCL:READ-UINT8-LE
;         (STREAM)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Reads an 8 byte unsigned integer (little-endian)."
;       (DECLARE
;        (OPTIMIZE (SPEED 3) (COMPILATION-SPEED 0) (SAFETY 0) (SPACE 0)
;         (DEBUG 0))
;        (TYPE STREAM STREAM))
;       (BLOCK KMRCL:READ-UINT8-LE
;         (LET ((KMRCL::VAL 0))
;           (DECLARE (TYPE # KMRCL::VAL))
;           (SETF # #)
;           (SETF # #)
;           (SETF # #)
;           (SETF # #)
;           (SETF # #)
;           (SETF # #)
;           (SETF # #)
;           (SETF # #)
;           KMRCL::VAL)))
; 
; note: doing unsigned word to integer coercion (cost 20) from VAL to "<return value>"

; --> PROGN KMRCL:DEF-UNSIGNED-INT-IO EVAL-WHEN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK WHEN IF PROGN WHEN IF 
; --> MINUSP 
; ==>
;   (< KMRCL::VAL 0)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (INTEGER * 18446744073709551615), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 18446744073709551615), not a FIXNUM.

; --> PROGN KMRCL:DEF-UNSIGNED-INT-IO EVAL-WHEN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK LET SETF LET* 
; ==>
;   (SETQ KMRCL::VAL (DPB #:NEW38 (BYTE 8 56) KMRCL::VAL))
; 
; note: doing unsigned word to integer coercion (cost 20) to VAL

; --> PROGN KMRCL:DEF-UNSIGNED-INT-IO EVAL-WHEN DEFUN PROGN SB-IMPL::%DEFUN 
; --> SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION BLOCK WHEN IF PROGN WHEN IF 
; --> MINUSP 
; ==>
;   (< KMRCL::VAL 0)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (INTEGER * 18446744073709551615), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER * 18446744073709551615), not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/strings.lisp
; in: DEFUN USB8-ARRAY-TO-STRING
;     (- KMRCL::END KMRCL::START)
; 
; 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.
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (SIGNED-BYTE 64).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/strings.lisp
; in: DEF-PREFIXED-NUMBER-STRING PREFIXED-FIXNUM-STRING
;     (KMRCL::DEF-PREFIXED-NUMBER-STRING KMRCL:PREFIXED-FIXNUM-STRING FIXNUM
;                                        "Outputs a string of LEN digit with an optional initial character PCHAR.
;   Leading zeros are present. LEN must be a fixnum.")
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* MOD NTH-VALUE MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a FIXNUM, not a (UNSIGNED-BYTE 64).

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* TAGBODY SETQ SETQ THE NTH-VALUE MULTIPLE-VALUE-BIND 
; --> LET FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a (OR (INTEGER -4611686018427387904 -1) (INTEGER 1 4611686018427387903)), not a (UNSIGNED-BYTE 64).

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* TAGBODY SETQ SETQ THE MOD NTH-VALUE 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FLOOR MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a (INTEGER -461168601842738791 461168601842738790), not a (UNSIGNED-BYTE 64).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/strings.lisp
; in: DEF-PREFIXED-NUMBER-STRING PREFIXED-INTEGER-STRING
;     (KMRCL::DEF-PREFIXED-NUMBER-STRING KMRCL:PREFIXED-INTEGER-STRING INTEGER
;                                        "Outputs a string of LEN digit with an optional initial character PCHAR.
;   Leading zeros are present. LEN must be an integer.")
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* MOD NTH-VALUE MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* TAGBODY SETQ SETQ THE NTH-VALUE MULTIPLE-VALUE-BIND 
; --> LET FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a (OR (INTEGER * -1) (INTEGER 1)), not a (UNSIGNED-BYTE 64).

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* TAGBODY SETQ SETQ THE MOD NTH-VALUE 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FLOOR MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* MINUSP < IF 
; ==>
;   (< KMRCL::NUM 0)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* IF - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER KMRCL::NUM))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK DO* BLOCK LET* TAGBODY SETQ SETQ THE NTH-VALUE MULTIPLE-VALUE-BIND 
; --> LET FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1- 
; ==>
;   (- SB-C::TRU 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/strings.lisp
; in: DEFUN INTEGER-STRING
;     (MOD KMRCL::VAL 10)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).

;     (FLOOR KMRCL::VAL 10)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a (OR (INTEGER * -1) (INTEGER 1)), not a (UNSIGNED-BYTE 64).

;     (MOD KMRCL::VAL 10)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FLOOR 
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (TRUNCATE NUMBER SB-C::DIVISOR)
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).

;     (MINUSP KMRCL::NUM)
; --> < IF 
; ==>
;   (< KMRCL::NUM 0)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (- 0 KMRCL::NUM)
; ==>
;   (SB-KERNEL:%NEGATE SB-C::Y)
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (FLOOR KMRCL::VAL 10)
; --> MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF VALUES 1- 
; ==>
;   (- SB-C::TRU 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/strings.lisp
; in: DEFUN COUNT-STRING-CHAR-IF
;     (FUNCALL KMRCL::PRED (SCHAR KMRCL::S KMRCL::I))
; --> SB-C::%FUNCALL THE 
; ==>
;   (SB-KERNEL:%COERCE-CALLABLE-FOR-CALL KMRCL::PRED)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: PRED is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/strings.lisp
; in: DEFUN SPLIT-ALPHANUMERIC-STRING
;     (POSITION-IF-NOT #'KMRCL::IS-SEP STRING)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION-IF-NOT
;    (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C::PREDICATE) SEQUENCE SB-C::FROM-END
;    SB-C::START SB-C::END (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
; 
; note: unable to expand inline because: upgraded array element type not known at compile time

;     (POSITION-IF #'KMRCL::IS-SEP STRING :START KMRCL::TOKEN-START)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION-IF
;    (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C::PREDICATE) SEQUENCE SB-C::FROM-END
;    SB-C::START SB-C::END (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
; 
; note: unable to expand inline because: upgraded array element type not known at compile time

;     (POSITION-IF-NOT #'KMRCL::IS-SEP STRING :START (1+ KMRCL::TOKEN-END))
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION-IF-NOT
;    (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C::PREDICATE) SEQUENCE SB-C::FROM-END
;    SB-C::START SB-C::END (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
; 
; note: unable to expand inline because: upgraded array element type not known at compile time

;     (POSITION-IF #'KMRCL::IS-SEP STRING :START KMRCL::TOKEN-START)
; --> NTH-VALUE MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   (SB-KERNEL:%FIND-POSITION-IF
;    (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C::PREDICATE) SEQUENCE SB-C::FROM-END
;    SB-C::START SB-C::END (SB-KERNEL:EFFECTIVE-FIND-POSITION-KEY SB-C::KEY))
; 
; note: unable to expand inline because: upgraded array element type not known at compile time

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/buff-input.lisp
; in: DEFUN READ-BUFFERED-FIELDS
;     (SETF (CHAR KMRCL::FIELD KMRCL::IPOS) KMRCL::RC)
; --> SB-KERNEL:%CHARSET SETF LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a BASE-STRING, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a BASE-STRING, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/buff-input.lisp
; in: DEFUN READ-BUFFERED-FIELDS2
;     (AREF (KMRCL::FIELD-BUFFERS-BUFFERS KMRCL::FIELDS) KMRCL::IFIELD)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (SETF (AREF (KMRCL::FIELD-BUFFERS-FIELD-LENGTHS KMRCL::FIELDS) KMRCL::IFIELD)
;             KMRCL::IPOS)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY SB-INT:INDEX SB-C::NEW-VALUE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/buff-input.lisp
; in: DEFUN BFIELD
;     (AREF (KMRCL::FIELD-BUFFERS-BUFFERS KMRCL::FIELDS) KMRCL::I)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF (KMRCL::FIELD-BUFFERS-FIELD-LENGTHS KMRCL::FIELDS) KMRCL::I)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (SUBSEQ (AREF (KMRCL::FIELD-BUFFERS-BUFFERS KMRCL::FIELDS) KMRCL::I) 0
;             (AREF (KMRCL::FIELD-BUFFERS-FIELD-LENGTHS KMRCL::FIELDS) KMRCL::I))
; 
; 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 LIST.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a SB-KERNEL:EXTENDED-SEQUENCE.

;     (>= KMRCL::I (KMRCL::FIELD-BUFFERS-NFIELDS KMRCL::FIELDS))
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT * 4.611686018427388d18) (SINGLE-FLOAT * 4.611686e18) (RATIONAL * 4611686018427387903)), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/buff-input.lisp
; in: DEFUN READ-BUFFERED-LINE
;     (SETF (CHAR KMRCL::LINEBUFFER KMRCL::POS) KMRCL::C)
; --> SB-KERNEL:%CHARSET SETF LET* THE 
; ==>
;   KMRCL::LINEBUFFER
; 
; note: deleting unreachable code

; --> SB-KERNEL:%CHARSET SETF LET* 
; ==>
;   KMRCL::POS
; 
; note: deleting unreachable code

; ==>
;   KMRCL::C
; 
; note: deleting unreachable code

;     (INCF KMRCL::POS)
; --> SETQ THE + 
; ==>
;   KMRCL::POS
; 
; note: deleting unreachable code

;     (WARN "Line overflow")
; ==>
;   "Line overflow"
; 
; note: deleting unreachable code

;     (SETF (FILL-POINTER KMRCL::LINEBUFFER) (1- KMRCL::POS))
; --> SB-KERNEL:%SET-FILL-POINTER 
; ==>
;   KMRCL::LINEBUFFER
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/color.lisp
; in: DEFUN HSV->RGB
;     (ZEROP KMRCL::S)
; ==>
;   (= KMRCL::S 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 open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

;     (MINUSP KMRCL::H)
; ==>
;   (< KMRCL::H 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (/ KMRCL::H 60)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT * 360.0d0) (SINGLE-FLOAT * 360.0) (RATIONAL * 360)), not a INTEGER.

;     (TRUNCATE KMRCL::H-POS)
; --> TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (RATIONAL * 6) (SINGLE-FLOAT * 6.0) (DOUBLE-FLOAT * 6.0d0)), not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (RATIONAL * 6) (SINGLE-FLOAT * 6.0) (DOUBLE-FLOAT * 6.0d0)), not a DOUBLE-FLOAT.

;     (* KMRCL::V (- 1 KMRCL::S))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* KMRCL::S KMRCL::H-FRAC)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a INTEGER.

;     (* KMRCL::V (- 1 (* KMRCL::S KMRCL::H-FRAC)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* KMRCL::S (- 1 KMRCL::H-FRAC))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL (0) (2))), not a INTEGER.

;     (* KMRCL::V (- 1 (* KMRCL::S (- 1 KMRCL::H-FRAC))))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (INCF KMRCL::H 360)
; --> SETQ THE 
; ==>
;   (+ 360 KMRCL::H)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT * (0.0d0)) (SINGLE-FLOAT * (0.0)) (RATIONAL * (0))), not a RATIONAL.

;     (>= KMRCL::H 360)
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT * 360.0d0) (SINGLE-FLOAT * 360.0) (RATIONAL * 360)), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MINUSP KMRCL::H)
; ==>
;   (< KMRCL::H 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.

;     (INCF KMRCL::H 360)
; --> SETQ THE 
; ==>
;   (+ 360 KMRCL::H)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR (DOUBLE-FLOAT * (0.0d0)) (SINGLE-FLOAT * (0.0)) (RATIONAL * (0))), not a FIXNUM.
;       The result is a (VALUES (OR (RATIONAL * (360)) (SINGLE-FLOAT * 360.0) (DOUBLE-FLOAT * 360.0d0)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT * (0.0d0)) (SINGLE-FLOAT * (0.0)) (RATIONAL * (0))), not a FIXNUM.
;       The result is a (VALUES (OR (RATIONAL * (360)) (SINGLE-FLOAT * 360.0) (DOUBLE-FLOAT * 360.0d0)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (>= KMRCL::H 360)
; --> OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; 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.

;     (TRUNCATE KMRCL::H-POS)
; --> TRUNCATE LET VALUES LOCALLY 
; ==>
;   (- SB-C::X SB-C::RES)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (RATIONAL * 6) (SINGLE-FLOAT * 6.0) (DOUBLE-FLOAT * 6.0d0)), not a FIXNUM.
;       The second argument is a (INTEGER * 7), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (RATIONAL * 6) (SINGLE-FLOAT * 6.0) (DOUBLE-FLOAT * 6.0d0)), not a (SIGNED-BYTE 64).
;       The second argument is a (INTEGER * 7), not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- 1 KMRCL::S)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* KMRCL::V (- 1 KMRCL::S))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (* KMRCL::S KMRCL::H-FRAC)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (- 1 (* KMRCL::S KMRCL::H-FRAC))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* KMRCL::V (- 1 (* KMRCL::S KMRCL::H-FRAC)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (- 1 KMRCL::H-FRAC)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a FIXNUM.
;       The result is a (VALUES (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL (0) (2))) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR (RATIONAL (-1) (1)) DOUBLE-FLOAT SINGLE-FLOAT), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL (0) (2))) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* KMRCL::S (- 1 KMRCL::H-FRAC))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL (0) (2))), not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (OR SINGLE-FLOAT DOUBLE-FLOAT (RATIONAL (0) (2))), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (- 1 (* KMRCL::S (- 1 KMRCL::H-FRAC)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* KMRCL::V (- 1 (* KMRCL::S (- 1 KMRCL::H-FRAC))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       etc.

;     (DECF KMRCL::H 360)
; --> SETQ THE SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/color.lisp
; in: DEFUN HSV255->RGB255
;     (ZEROP KMRCL::S)
; ==>
;   (= KMRCL::S 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 open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open code because: The operands might not be the same type.

;     (* 255 KMRCL::FV (- 1 KMRCL::FS))
; --> * 
; ==>
;   (* 255 KMRCL::FV)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a INTEGER.

; ==>
;   (* (* 255 KMRCL::FV) (- 1 KMRCL::FS))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a INTEGER.The second argument is a (RATIONAL -1537228672809129216/85 4611686018427388159/255), not a INTEGER.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; --> * 
; ==>
;   (* 255 KMRCL::FV)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a INTEGER.

;     (* KMRCL::FS KMRCL::H-FRAC)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a INTEGER.The second argument is a (RATIONAL (-1) (1)), not a INTEGER.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; ==>
;   (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a INTEGER.The second argument is a (RATIONAL (-4611686018427387649/255) (4611686018427388159/255)), not a INTEGER.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; --> * 
; ==>
;   (* 255 KMRCL::FV)
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a INTEGER.

;     (* KMRCL::FS (- 1 KMRCL::H-FRAC))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a INTEGER.The second argument is a (RATIONAL (0) (2)), not a INTEGER.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; ==>
;   (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a INTEGER.The second argument is a (RATIONAL (-3074457345618258517/85) (9223372036854776063/255)), not a INTEGER.

;     (TRUNCATE KMRCL::H-POS)
; --> TRUNCATE LET VALUES LOCALLY 
; ==>
;   (- SB-C::X SB-C::RES)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -1152921504606846976/15 359/60), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-1) (1)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL -1152921504606846976/15 359/60), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-1) (1)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* 255 KMRCL::FV (- 1 KMRCL::FS))
; --> * 
; ==>
;   (* 255 KMRCL::FV)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -4611686018427387904 4611686018427387903) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -4611686018427387904 4611686018427387903) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- 1 KMRCL::FS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -1537228672809129216/85 4611686018427388159/255) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL -1537228672809129216/85 4611686018427388159/255) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* 255 KMRCL::FV (- 1 KMRCL::FS))
; ==>
;   (* (* 255 KMRCL::FV) (- 1 KMRCL::FS))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a FIXNUM.
;       The second argument is a (RATIONAL -1537228672809129216/85 4611686018427388159/255), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -21267647932558655142440847663469428736/255 7089215977519551712609720548347346859/85) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a (SIGNED-BYTE 64).
;       The second argument is a (RATIONAL -1537228672809129216/85 4611686018427388159/255), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL -21267647932558655142440847663469428736/255 7089215977519551712609720548347346859/85) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; --> * 
; ==>
;   (* 255 KMRCL::FV)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -4611686018427387904 4611686018427387903) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -4611686018427387904 4611686018427387903) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (* KMRCL::FS KMRCL::H-FRAC)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The second argument is a (RATIONAL (-1) (1)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-4611686018427387904/255) (4611686018427387904/255)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a (SIGNED-BYTE 64).
;       The second argument is a (RATIONAL (-1) (1)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-4611686018427387904/255) (4611686018427387904/255)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- 1 (* KMRCL::FS KMRCL::H-FRAC))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (RATIONAL (-4611686018427387904/255) (4611686018427387904/255)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-4611686018427387649/255) (4611686018427388159/255)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a (RATIONAL (-4611686018427387904/255) (4611686018427387904/255)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-4611686018427387649/255) (4611686018427388159/255)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; ==>
;   (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS KMRCL::H-FRAC)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a FIXNUM.
;       The second argument is a (RATIONAL (-4611686018427387649/255) (4611686018427388159/255)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-21267647932558655142440847663469428736/255) (7089215977519551712609720548347346859/85)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a (SIGNED-BYTE 64).
;       The second argument is a (RATIONAL (-4611686018427387649/255) (4611686018427388159/255)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-21267647932558655142440847663469428736/255) (7089215977519551712609720548347346859/85)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; --> * 
; ==>
;   (* 255 KMRCL::FV)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -4611686018427387904 4611686018427387903) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The result is a (VALUES (RATIONAL -4611686018427387904 4611686018427387903) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- 1 KMRCL::H-FRAC)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (RATIONAL (-1) (1)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (0) (2)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a (RATIONAL (-1) (1)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (0) (2)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* KMRCL::FS (- 1 KMRCL::H-FRAC))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a FIXNUM.
;       The second argument is a (RATIONAL (0) (2)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-9223372036854775808/255) (3074457345618258602/85)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL -4611686018427387904/255 1537228672809129301/85), not a (SIGNED-BYTE 64).
;       The second argument is a (RATIONAL (0) (2)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-9223372036854775808/255) (3074457345618258602/85)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (RATIONAL (-9223372036854775808/255) (3074457345618258602/85)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-3074457345618258517/85) (9223372036854776063/255)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a (RATIONAL (-9223372036854775808/255) (3074457345618258602/85)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-3074457345618258517/85) (9223372036854776063/255)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (* 255 KMRCL::FV (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; ==>
;   (* (* 255 KMRCL::FV) (- 1 (* KMRCL::FS (- 1 KMRCL::H-FRAC))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a FIXNUM.
;       The second argument is a (RATIONAL (-3074457345618258517/85) (9223372036854776063/255)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (-42535295865117309108901760627954941952/255) (14178431955039103033226129530366721963/85)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL -4611686018427387904 4611686018427387903), not a (SIGNED-BYTE 64).
;       The second argument is a (RATIONAL (-3074457345618258517/85) (9223372036854776063/255)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (-42535295865117309108901760627954941952/255) (14178431955039103033226129530366721963/85)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/color.lisp
; in: DEFUN RGB->HSV
;     (PLUSP MAX)
; ==>
;   (> MAX 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (/ KMRCL::DELTA MAX)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.

;     (PLUSP KMRCL::DELTA)
; ==>
;   (> KMRCL::DELTA 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (= MAX KMRCL::R)
; 
; 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 open code because: The operands might not be the same type.

;     (/ (- KMRCL::G KMRCL::B) KMRCL::DELTA)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.

;     (= MAX KMRCL::G)
; 
; 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 open code because: The operands might not be the same type.

;     (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.

;     (+ 2 (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA))
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA)
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a INTEGER.

;     (+ 4 (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA))
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (* 60
;        (COND ((= MAX KMRCL::R) (/ (- KMRCL::G KMRCL::B) KMRCL::DELTA))
;              ((= MAX KMRCL::G) (+ 2 (/ # KMRCL::DELTA)))
;              (T (+ 4 (/ # KMRCL::DELTA)))))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to associate */(* /) of constants due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (MINUSP KMRCL::H)
; ==>
;   (< KMRCL::H 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (INCF KMRCL::H 360)
; --> SETQ THE 
; ==>
;   (+ 360 KMRCL::H)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT * (0.0d0)) (SINGLE-FLOAT * (0.0)) (RATIONAL * (0))), not a RATIONAL.

;     (MIN KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MIN LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET MIN LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; 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 open code because: The operands might not be the same type.

; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; 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 open code because: The operands might not be the same type.

;     (MAX KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MAX LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET MAX LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; 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 open code because: The operands might not be the same type.

; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; 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 open code because: The operands might not be the same type.

;     (MIN KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MIN LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET MIN LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

; --> LET LET IF <= OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET IF <= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

;     (MAX KMRCL::R KMRCL::G KMRCL::B)
; --> LET LET MAX LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET MAX LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

; --> LET LET IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; 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.

; --> LET LET IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

;     (- MAX MIN)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (PLUSP MAX)
; ==>
;   (> MAX 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.

;     (/ KMRCL::DELTA MAX)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (PLUSP KMRCL::DELTA)
; ==>
;   (> KMRCL::DELTA 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.

;     (= MAX KMRCL::R)
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

;     (- KMRCL::G KMRCL::B)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (/ (- KMRCL::G KMRCL::B) KMRCL::DELTA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (= MAX KMRCL::G)
; 
; note: forced to do GENERIC-= (cost 10)
;       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.
;       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.

;     (- KMRCL::B KMRCL::R)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ 2 (/ (- KMRCL::B KMRCL::R) KMRCL::DELTA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (- KMRCL::R KMRCL::G)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a (OR (DOUBLE-FLOAT (0.0d0)) (SINGLE-FLOAT (0.0)) (RATIONAL (0))), not a DOUBLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (+ 4 (/ (- KMRCL::R KMRCL::G) KMRCL::DELTA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (* 60
;        (COND ((= MAX KMRCL::R) (/ (- KMRCL::G KMRCL::B) KMRCL::DELTA))
;              ((= MAX KMRCL::G) (+ 2 (/ # KMRCL::DELTA)))
;              (T (+ 4 (/ # KMRCL::DELTA)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (MINUSP KMRCL::H)
; ==>
;   (< KMRCL::H 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.

;     (INCF KMRCL::H 360)
; --> SETQ THE 
; ==>
;   (+ 360 KMRCL::H)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR (DOUBLE-FLOAT * (0.0d0)) (SINGLE-FLOAT * (0.0)) (RATIONAL * (0))), not a FIXNUM.
;       The result is a (VALUES (OR (RATIONAL * (360)) (SINGLE-FLOAT * 360.0) (DOUBLE-FLOAT * 360.0d0)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (DOUBLE-FLOAT * (0.0d0)) (SINGLE-FLOAT * (0.0)) (RATIONAL * (0))), not a FIXNUM.
;       The result is a (VALUES (OR (RATIONAL * (360)) (SINGLE-FLOAT * 360.0) (DOUBLE-FLOAT * 360.0d0)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/color.lisp
; in: DEFUN RGB255->HSV255
;     (+ 240 (ROUND (THE FIXNUM (* 60 (THE FIXNUM #))) KMRCL::DELTA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (+ 120 (ROUND (THE FIXNUM (* 60 (THE FIXNUM #))) KMRCL::DELTA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/color.lisp
; in: DEFUN HSV-EQUAL
;     (ABS (- KMRCL::A KMRCL::B))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (< (ABS (- KMRCL::A KMRCL::B)) KMRCL::LIMIT)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.The second argument is a REAL, not a RATIONAL.

;     (- KMRCL::A KMRCL::B)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (ABS (- KMRCL::A KMRCL::B))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (< (ABS (- KMRCL::A KMRCL::B)) KMRCL::LIMIT)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), 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 (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/color.lisp
; in: DEFUN HSV255-EQUAL
;     (NULL KMRCL::B)
; --> IF 
; ==>
;   KMRCL::B
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/color.lisp
; in: DEFUN HSV255-SIMILAR
;     (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (<= (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2)) KMRCL::HUE-RANGE)
; --> OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.

; --> OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (<= (ABS (KMRCL:HUE-DIFFERENCE-FIXNUM KMRCL::H1 KMRCL::H2)) KMRCL::HUE-RANGE)
; --> OR LET < IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR (DOUBLE-FLOAT 0.0d0) (SINGLE-FLOAT 0.0) (RATIONAL 0)), not a FIXNUM.
; 
; caught ERROR:
;   READ error during COMPILE-FILE: The symbol "SLOT-DEFINITION-NAME" is not external in the SB-PCL package. Line: 94, Column: 32, File-Position: 3190 Stream: #<SB-INT:FORM-TRACKING-STREAM for "file /home/quicklisp/quicklisp-controller/dist/build-cache/kmrcl/4fa994e358e4b454880961a4e0156e29e32f63ba/kmrcl-20200624-git/mop.lisp" {1007F0AB13}>
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1000A30083}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "kmrcl" "mop">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1000A30083}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100805C663}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100805C663}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {100805C663}>)
3: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">)))
4: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">)
6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
7: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "kmrcl" "mop">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005275663}>) [fast-method]
9: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
10: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005275663}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "hyperobject-tests"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
12: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "hyperobject-tests">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "hyperobject-tests">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "hyperobject-tests")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "hyperobject-tests") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100526E59B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10052293BB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "hyperobject-tests") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "hyperobject-tests" "hyperobject-tests")
23: (DEPCHECK::MAGIC "hyperobject-tests" "hyperobject-tests" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-O3tvbTWE/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "hyperobject-tests" "hyperobject-tests" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-O3tvbTWE/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-O3tvbTWE/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-14" :IN SAVE-LISP-AND-DIE))
28: ((LABELS SB-IMPL::RESTART-LISP :IN SAVE-LISP-AND-DIE))

unhandled condition in --disable-debugger mode, quitting
; 
; compilation unit aborted
;   caught 2 fatal ERROR conditions
;   caught 1 ERROR condition
;   caught 2 STYLE-WARNING conditions
;   printed 181 notes