adw-charting

SBCL 2.1.7.62-417920f09 / ASDF 3.3.5

adw-charting

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/adw-charting/7a7e66124521f356ff6b6b9653f8b190b827b7e1/adw-charting-20211013-http/src/charting.lisp
; in: DEFCLASS AREA
;     (NET.ACCELERATION.CHARTING::HEIGHT :ACCESSOR
;      NET.ACCELERATION.CHARTING::HEIGHT :INITARG :HEIGHT :TYPE INTEGER :INITFORM
;      NIL)
; ==>
;   (SB-KERNEL:THE* (INTEGER :SOURCE-FORM NIL :USE-ANNOTATIONS T) NIL)
; 
; caught WARNING:
;   Constant NIL conflicts with its asserted type INTEGER.
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NET.ACCELERATION.CHARTING::WIDTH :ACCESSOR NET.ACCELERATION.CHARTING::WIDTH
;      :INITARG :WIDTH :TYPE INTEGER :INITFORM NIL)
; ==>
;   (SB-KERNEL:THE* (INTEGER :SOURCE-FORM NIL :USE-ANNOTATIONS T) NIL)
; 
; caught WARNING:
;   Constant NIL conflicts with its asserted type INTEGER.
;   See also:
;     The SBCL Manual, Node "Handling of Types"
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1001BF0103}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "adw-charting" "src" "charting">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1001BF0103}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {10065B4B83}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {10065B4B83}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {10065B4B83}>)
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 "adw-charting" "src" "charting">)))
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 "adw-charting" "src" "charting">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "adw-charting" "src" "charting">)
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 "adw-charting" "src" "charting">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {10058B5D73}>) [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 {10058B5D73}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "adw-charting"> :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 "adw-charting">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "adw-charting">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "adw-charting")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "adw-charting") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10058AED1B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100587136B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "adw-charting") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "adw-charting" "adw-charting")
23: (DEPCHECK::MAGIC "adw-charting" "adw-charting" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-Lko942hA/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "adw-charting" "adw-charting" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-Lko942hA/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-Lko942hA/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-IMPL::START-LISP))
28: (SB-IMPL::START-LISP)

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

adw-charting-vecto

WARNING: redefining ZPB-TTF::LOCATION in DEFGENERIC

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/adw-charting/7a7e66124521f356ff6b6b9653f8b190b827b7e1/adw-charting-20211013-http/src/charting.lisp
; in: DEFCLASS AREA
;     (NET.ACCELERATION.CHARTING::HEIGHT :ACCESSOR
;      NET.ACCELERATION.CHARTING::HEIGHT :INITARG :HEIGHT :TYPE INTEGER :INITFORM
;      NIL)
; ==>
;   (SB-KERNEL:THE* (INTEGER :SOURCE-FORM NIL :USE-ANNOTATIONS T) NIL)
; 
; caught WARNING:
;   Constant NIL conflicts with its asserted type INTEGER.
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NET.ACCELERATION.CHARTING::WIDTH :ACCESSOR NET.ACCELERATION.CHARTING::WIDTH
;      :INITARG :WIDTH :TYPE INTEGER :INITFORM NIL)
; ==>
;   (SB-KERNEL:THE* (INTEGER :SOURCE-FORM NIL :USE-ANNOTATIONS T) NIL)
; 
; caught WARNING:
;   Constant NIL conflicts with its asserted type INTEGER.
;   See also:
;     The SBCL Manual, Node "Handling of Types"
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1001BF0103}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "adw-charting" "src" "charting">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1001BF0103}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {10071E4EA3}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {10071E4EA3}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {10071E4EA3}>)
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 "adw-charting" "src" "charting">)))
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 "adw-charting" "src" "charting">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "adw-charting" "src" "charting">)
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 "adw-charting" "src" "charting">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {10058B04D3}>) [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 {10058B04D3}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "adw-charting-vecto"> :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 "adw-charting-vecto">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "adw-charting-vecto">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "adw-charting-vecto")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "adw-charting-vecto") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10058A91AB}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100586B7BB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "adw-charting-vecto") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "adw-charting-vecto" "adw-charting-vecto")
23: (DEPCHECK::MAGIC "adw-charting-vecto" "adw-charting-vecto" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-mmvtYT2W/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "adw-charting-vecto" "adw-charting-vecto" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-mmvtYT2W/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-mmvtYT2W/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-IMPL::START-LISP))
28: (SB-IMPL::START-LISP)

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

adw-charting-google

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/flexi-streams/2f04ab423f3e13bad09bf311dd863838fec643be/flexi-streams-20211013-git/flexi-streams.asd" contains definition for system "flexi-streams-test". Please only define "flexi-streams" and secondary systems with a name starting with "flexi-streams/" (e.g. "flexi-streams/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/encode.lisp
; in: DEFUN ROUND-NEXT-MULTIPLE
;     (MOD CL-BASE64::X CL-BASE64::N)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-4611686018427387904) (4611686018427387904))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-4611686018427387904) (4611686018427387904))), not a FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (+ CL-BASE64::X (THE FIXNUM (- CL-BASE64::N CL-BASE64::REMAINDER)))
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (MOD CL-BASE64::X CL-BASE64::N)
; 
; 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.
; 
; 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.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT (RATIONAL (-4611686018427387904) (4611686018427387904))), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL (-9223372036854775808) (9223372036854775807))) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR FLOAT (RATIONAL (-4611686018427387904) (4611686018427387904))), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR FLOAT (RATIONAL (-9223372036854775808) (9223372036854775807))) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (RATIONAL (-9223372036854775808) (9223372036854775807)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (RATIONAL (-9223372036854775808) (9223372036854775807)), not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline (unsigned-byte 64) comparison (cost 5) because:
;       The first argument is a (RATIONAL (-4611686018427387904) (9223372036854775807)), not a (UNSIGNED-BYTE 64).
;       unable to do inline (signed-byte 64) comparison (cost 5) because:
;       The first argument is a (RATIONAL (-4611686018427387904) (9223372036854775807)), not a (SIGNED-BYTE 64).

;     (+ CL-BASE64::X (THE FIXNUM (- CL-BASE64::N CL-BASE64::REMAINDER)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       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).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (SIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/encode.lisp
; in: DEF-*-TO-BASE64-* :STRING
;     (CL-BASE64::DEF-*-TO-BASE64-* :STRING :STRING)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH CHAR-CODE THE 
; ==>
;   (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; ==>
;   (CHAR CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH CHAR-CODE THE 
; ==>
;   (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY 
; --> CL-BASE64::OUTPUT-GROUP THE 
; ==>
;   (+ (THE FIXNUM (ASH (THE FIXNUM (CHAR-CODE #)) 16))
;      (THE FIXNUM (ASH (THE FIXNUM (CHAR-CODE #)) 8))
;      (THE FIXNUM (CHAR-CODE (THE CHARACTER (CHAR CL-BASE64::INPUT #)))))
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/encode.lisp
; in: DEF-*-TO-BASE64-* :STRING
;     (CL-BASE64::DEF-*-TO-BASE64-* :STRING :STREAM)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH CHAR-CODE THE 
; ==>
;   (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; ==>
;   (CHAR CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH CHAR-CODE THE 
; ==>
;   (CHAR CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY 
; --> CL-BASE64::OUTPUT-GROUP THE 
; ==>
;   (+ (THE FIXNUM (ASH (THE FIXNUM (CHAR-CODE #)) 16))
;      (THE FIXNUM (ASH (THE FIXNUM (CHAR-CODE #)) 8))
;      (THE FIXNUM (CHAR-CODE (THE CHARACTER (CHAR CL-BASE64::INPUT #)))))
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/encode.lisp
; in: DEF-*-TO-BASE64-* :USB8-ARRAY
;     (CL-BASE64::DEF-*-TO-BASE64-* :USB8-ARRAY :STRING)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH THE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; ==>
;   (AREF CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH THE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY 
; --> CL-BASE64::OUTPUT-GROUP THE 
; ==>
;   (+
;    (THE FIXNUM
;         (ASH (THE FIXNUM (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)) 16))
;    (THE FIXNUM (ASH (THE FIXNUM (AREF CL-BASE64::INPUT #)) 8))
;    (THE FIXNUM (AREF CL-BASE64::INPUT (+ 2 CL-BASE64::ISOURCE))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/encode.lisp
; in: DEF-*-TO-BASE64-* :USB8-ARRAY
;     (CL-BASE64::DEF-*-TO-BASE64-* :USB8-ARRAY :STREAM)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF 
; --> CL-BASE64::OUTPUT-GROUP THE + THE ASH THE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; ==>
;   (AREF CL-BASE64::INPUT (THE FIXNUM (1+ CL-BASE64::ISOURCE)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY RETURN-FROM PROGN COND IF IF 
; --> CL-BASE64::OUTPUT-GROUP THE ASH THE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LET LET* LABELS DO BLOCK LET TAGBODY TAGBODY 
; --> CL-BASE64::OUTPUT-GROUP THE 
; ==>
;   (+
;    (THE FIXNUM
;         (ASH (THE FIXNUM (AREF CL-BASE64::INPUT CL-BASE64::ISOURCE)) 16))
;    (THE FIXNUM (ASH (THE FIXNUM (AREF CL-BASE64::INPUT #)) 8))
;    (THE FIXNUM (AREF CL-BASE64::INPUT (+ 2 CL-BASE64::ISOURCE))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/encode.lisp
; in: DEFUN INTEGER-TO-BASE64-STRING
;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (SIGNED-BYTE 64).
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

;     (ZEROP CL-BASE64::REMAINDER-PADDING)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 (24))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FLOAT.
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (- 24 CL-BASE64::REMAINDER-PADDING)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a FLOAT.

;     (/ CL-BASE64::PADDING-BITS 6)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a FLOAT.
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a RATIONAL.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a DOUBLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a SINGLE-FLOAT.

;     (/ (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS) 6)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (/ CL-BASE64::PADDING-BITS 3)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a FLOAT.
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.

;     (INTEGER-LENGTH CL-BASE64::INPUT)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; 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.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) (48))) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) (48))) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (RATIONAL (-24) (48)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (RATIONAL (-24) (48)), not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (RATIONAL 0 (48)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (RATIONAL 0 (48)), not a FIXNUM.
;       etc.

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

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; 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 (OR FLOAT (RATIONAL 0 24)), 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 (OR FLOAT (RATIONAL 0 24)), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* CL-BASE64::COLUMNS (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES (INTEGER -21267647932558653961849226946058125312 21267647932558653957237540927630737409) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The result is a (VALUES (INTEGER -21267647932558653961849226946058125312 21267647932558653957237540927630737409) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (- CL-BASE64::PADDED-LENGTH
;        (* CL-BASE64::COLUMNS
;           (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (INTEGER -21267647932558653961849226946058125312 21267647932558653957237540927630737409), not a FIXNUM.
;       The result is a (VALUES (INTEGER -21267647932558653961849226946058125313 21267647932558653966460912964485513215) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a (INTEGER -21267647932558653961849226946058125312 21267647932558653957237540927630737409), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER -21267647932558653961849226946058125313 21267647932558653966460912964485513215) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (ASH CL-BASE64::INPUT (/ CL-BASE64::PADDING-BITS 3))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR FLOAT (RATIONAL 0 8)), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR FLOAT (RATIONAL 0 8)), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH CL-BASE64::INT -6)
; 
; note: forced to do full call
;       unable to do inline ASH (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).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/encode.lisp
; in: DEFUN INTEGER-TO-BASE64-STREAM
;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (SIGNED-BYTE 64).
; 
; note: unable to convert integer division to multiplication due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 64).

;     (ZEROP CL-BASE64::REMAINDER-PADDING)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 (24))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FLOAT.
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (- 24 CL-BASE64::REMAINDER-PADDING)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a FLOAT.

;     (/ CL-BASE64::PADDING-BITS 6)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a FLOAT.
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a RATIONAL.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a DOUBLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a (OR FLOAT (RATIONAL 0 24)), not a SINGLE-FLOAT.

;     (/ (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS) 6)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (- CL-BASE64::STRLEN CL-BASE64::PADDING-CHARS)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The second argument is a (OR FLOAT (RATIONAL 0 4)), not a FLOAT.

;     (1- CL-BASE64::NONPAD-CHARS)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL -4611686018427387908 4611686018427387903)), not a FLOAT.

;     (/ CL-BASE64::PADDING-BITS 3)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a FLOAT.
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.

;     (= CL-BASE64::STRPOS CL-BASE64::NONPAD-CHARS)
; 
; note: unable to open code because: The operands might not be the same type.

;     (INTEGER-LENGTH CL-BASE64::INPUT)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       etc.

;     (MOD CL-BASE64::PADDED-BITS 24)
; 
; 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.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) (48))) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT (RATIONAL (-24) (24))), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) (48))) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (RATIONAL (-24) (48)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (RATIONAL (-24) (48)), not a FIXNUM.
;       etc.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (RATIONAL 0 (48)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (RATIONAL 0 (48)), not a FIXNUM.
;       etc.

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

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; 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 (OR FLOAT (RATIONAL 0 24)), 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 (OR FLOAT (RATIONAL 0 24)), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (- CL-BASE64::STRLEN CL-BASE64::PADDING-CHARS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 4)), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL -4611686018427387908 4611686018427387903)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 4)), not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR FLOAT (RATIONAL -4611686018427387908 4611686018427387903)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (1- CL-BASE64::NONPAD-CHARS)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR FLOAT (RATIONAL -4611686018427387908 4611686018427387903)), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL -4611686018427387909 4611686018427387902)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR FLOAT (RATIONAL -4611686018427387908 4611686018427387903)), not a FIXNUM.
;       The result is a (VALUES (OR FLOAT (RATIONAL -4611686018427387909 4611686018427387902)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH CL-BASE64::INPUT (/ CL-BASE64::PADDING-BITS 3))
; 
; note: forced to do full call
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR FLOAT (RATIONAL 0 8)), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (OR FLOAT (RATIONAL 0 8)), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH CL-BASE64::INT -6)
; 
; note: forced to do full call
;       unable to do inline ASH (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).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/decode.lisp
; in: DEFINE-BASE64-DECODER :STRING
;     (CL-BASE64::DEFINE-BASE64-DECODER :STRING :USB8-ARRAY)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN IF SETQ THE CHAR-CODE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::IPOS)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/decode.lisp
; in: DEFINE-BASE64-DECODER :STRING
;     (CL-BASE64::DEFINE-BASE64-DECODER :STRING :STRING)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN IF SETQ THE CHAR-CODE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::IPOS)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/decode.lisp
; in: DEFINE-BASE64-DECODER :STRING
;     (CL-BASE64::DEFINE-BASE64-DECODER :STRING :INTEGER)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN IF SETQ THE CHAR-CODE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::IPOS)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE 
; --> LOGIOR 
; ==>
;   (ASH CL-BASE64::RESULT 8)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE 
; ==>
;   (LOGIOR (ASH CL-BASE64::RESULT 8) BYTE)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE 
; --> LOGIOR 
; ==>
;   (ASH CL-BASE64::RESULT 8)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE 
; ==>
;   (LOGIOR (ASH CL-BASE64::RESULT 8) BYTE)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK TAGBODY 
; --> PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE LOGIOR 
; ==>
;   (ASH CL-BASE64::RESULT 8)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK TAGBODY 
; --> PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE 
; ==>
;   (LOGIOR (ASH CL-BASE64::RESULT 8) BYTE)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/decode.lisp
; in: DEFINE-BASE64-DECODER :STRING
;     (CL-BASE64::DEFINE-BASE64-DECODER :STRING :STREAM)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET LET CL-BASE64::ETYPECASE/UNROLL 
; --> ETYPECASE LET COND IF IF IF PROGN CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN IF SETQ THE CHAR-CODE 
; ==>
;   (AREF CL-BASE64::INPUT CL-BASE64::IPOS)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20211013-git/decode.lisp
; in: DEFINE-BASE64-DECODER :STREAM
;     (CL-BASE64::DEFINE-BASE64-DECODER :STREAM :INTEGER)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE 
; --> LOGIOR 
; ==>
;   (ASH CL-BASE64::RESULT 8)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK CL-BASE64::LET/TYPED LET FLET CL-BASE64::LET/TYPED LET LOOP BLOCK 
; --> TAGBODY PROGN COND IF IF IF IF THE PROGN WHEN IF PROGN LET SETQ THE 
; ==>
;   (LOGIOR (ASH CL-BASE64::RESULT 8) BYTE)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/chunga/7a341e0e55681847160bce6941e8aec36f928228/chunga-20211013-git/read.lisp
; in: DEFUN TRIM-WHITESPACE
;     (CHAR STRING CHUNGA::I)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/usocket/12cc3af115d1d393cad4eae8e9b3e3aa123617ed/usocket-0.8.3/backend/sbcl.lisp
; in: DEFUN SOCKET-CONNECT
;     (USOCKET::%WITH-TIMEOUT (USOCKET::TIMEOUT (ERROR 'TIMEOUT))
;       (USOCKET::CONNECT))
; --> BLOCK TAGBODY FLET LET 
; ==>
;   (MAKE-TIMER #'#:G11)
; 
; note: could not stack allocate: (%WITH-TIMEOUT (TIMEOUT (ERROR (QUOTE SB-EXT:TIMEOUT))) (CONNECT))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/usocket/12cc3af115d1d393cad4eae8e9b3e3aa123617ed/usocket-0.8.3/backend/sbcl.lisp
; in: DEFMETHOD SOCKET-RECEIVE (DATAGRAM-USOCKET T T)
;     (DEFMETHOD USOCKET:SOCKET-RECEIVE
;                ((USOCKET:USOCKET USOCKET:DATAGRAM-USOCKET) USOCKET::BUFFER LENGTH
;                 &KEY (USOCKET::ELEMENT-TYPE '(UNSIGNED-BYTE 8)))
;       (DECLARE
;        (VALUES (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) (INTEGER 0)
;                (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) (UNSIGNED-BYTE 16)))
;       (USOCKET:WITH-MAPPED-CONDITIONS (USOCKET:USOCKET)
;         (LET ((USOCKET::S #))
;           (SB-BSD-SOCKETS:SOCKET-RECEIVE USOCKET::S USOCKET::BUFFER LENGTH
;                                          :ELEMENT-TYPE USOCKET::ELEMENT-TYPE))))
; --> PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD 
; --> SB-PCL::LOAD-DEFMETHOD LIST* LET* SB-INT:NAMED-LAMBDA FUNCTION 
; ==>
;   (THE
;    (VALUES (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) UNSIGNED-BYTE
;            (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) (UNSIGNED-BYTE 16) &REST T)
;    (PROGN
;     (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;       (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS (# SB-PCL::.NEXT-METHOD-CALL. #
;                                               NIL :CALL-NEXT-METHOD-P NIL
;                                               :SETQ-P NIL :PARAMETERS-SETQD NIL
;                                               :METHOD-CELL # ...)
;         (DECLARE #)
;         (LOCALLY # #)))))
; 
; note: Type assertion too complex to check:
; (VALUES (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) UNSIGNED-BYTE (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) (UNSIGNED-BYTE 16) &REST T).
; It allows an unknown number of values, consider using
; (VALUES (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) UNSIGNED-BYTE (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) (UNSIGNED-BYTE 16) &OPTIONAL).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/conditions.lisp
; in: DEFUN FORMAT-SSL-ERROR-QUEUE
;     'CL+SSL::SSL-ERROR
; 
; note: can't open-code test of unknown type SSL-ERROR

;     (ETYPECASE CL+SSL::QUEUE-DESIGNATOR
;       (CL+SSL::SSL-ERROR (CL+SSL::SSL-ERROR-QUEUE CL+SSL::QUEUE-DESIGNATOR))
;       (LIST CL+SSL::QUEUE-DESIGNATOR))
; --> LET COND IF 
; ==>
;   (TYPEP #:G2 'CL+SSL::SSL-ERROR)
; 
; note: can't open-code test of unknown type SSL-ERROR

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFMACRO DEFCFUN-LATE-BOUND
;     (LENGTH CL+SSL::NAME-AND-OPTIONS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLeay" CL+SSL::SSL-EAY)
;       :LONG)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-EAY
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-EAY
;         (CFFI-SYS:%FOREIGN-FUNCALL "SSLeay" (:LONG) :CONVENTION :CDECL :LIBRARY
;                                    CL+SSL/CONFIG::LIBCRYPTO)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION-EX (:SINCE "1.1.0")
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:SINCE "1.1.0")
;       ("OpenSSL_version_num" CL+SSL::OPENSSL-VERSION-NUM)
;       :LONG)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::OPENSSL-VERSION-NUM
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::OPENSSL-VERSION-NUM
;         (CFFI-SYS:%FOREIGN-FUNCALL "OpenSSL_version_num" (:LONG) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBCRYPTO)))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN OPENSSL-IS-AT-LEAST
;     (>= (CL+SSL::COMPAT-OPENSSL-VERSION)
;         (CL+SSL::ENCODE-OPENSSL-VERSION CL+SSL::MAJOR CL+SSL::MINOR CL+SSL::PATCH
;          CL+SSL::PRERELEASE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (DOUBLE-FLOAT * 8.15792463d8) (SINGLE-FLOAT * 8.1579245e8) (RATIONAL * 815792463)), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.
; 
; 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/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN OPENSSL-IS-NOT-EVEN
;     (< (CL+SSL::COMPAT-OPENSSL-VERSION)
;        (CL+SSL::ENCODE-OPENSSL-VERSION CL+SSL::MAJOR CL+SSL::MINOR CL+SSL::PATCH
;         CL+SSL::PRERELEASE))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; 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/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN LIBRESSLP
;     (= 536870912 (CL+SSL::COMPAT-OPENSSL-VERSION))
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("SSL_get_version" SSL-GET-VERSION)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_get_version" CL+SSL::SSL-GET-VERSION)
;       :STRING
;       (CL+SSL::SSL CL+SSL::SSL-POINTER))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK LET 
; ==>
;   (CFFI:TRANSLATE-FROM-FOREIGN
;    (CFFI-SYS:%FOREIGN-FUNCALL "SSL_get_version" (:POINTER #:G0 :POINTER)
;                               :CONVENTION :CDECL :LIBRARY
;                               CL+SSL/CONFIG::LIBSSL)
;    #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv23_client_method" CL+SSL::SSL-V23-CLIENT-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-V23-CLIENT-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-V23-CLIENT-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "SSLv23_client_method" (:POINTER)
;                                    :CONVENTION :CDECL :LIBRARY
;                                    CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv23_server_method" CL+SSL::SSL-V23-SERVER-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-V23-SERVER-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-V23-SERVER-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "SSLv23_server_method" (:POINTER)
;                                    :CONVENTION :CDECL :LIBRARY
;                                    CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv23_method" CL+SSL::SSL-V23-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-V23-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-V23-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "SSLv23_method" (:POINTER) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv3_client_method" CL+SSL::SSL-V3-CLIENT-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-V3-CLIENT-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-V3-CLIENT-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "SSLv3_client_method" (:POINTER) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv3_server_method" CL+SSL::SSL-V3-SERVER-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-V3-SERVER-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-V3-SERVER-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "SSLv3_server_method" (:POINTER) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv3_method" CL+SSL::SSL-V3-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-V3-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-V3-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "SSLv3_method" (:POINTER) :CONVENTION :CDECL
;                                    :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("TLSv1_client_method" SSL-TLSV1-CLIENT-METHOD)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("TLSv1_client_method" CL+SSL::SSL-TLSV1-CLIENT-METHOD)
;       CL+SSL::SSL-METHOD)
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-CLIENT-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-CLIENT-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_client_method" (:POINTER) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("TLSv1_server_method" SSL-TLSV1-SERVER-METHOD)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("TLSv1_server_method" CL+SSL::SSL-TLSV1-SERVER-METHOD)
;       CL+SSL::SSL-METHOD)
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-SERVER-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-SERVER-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_server_method" (:POINTER) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("TLSv1_method" SSL-TLSV1-METHOD)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("TLSv1_method" CL+SSL::SSL-TLSV1-METHOD)
;       CL+SSL::SSL-METHOD)
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_method" (:POINTER) :CONVENTION :CDECL
;                                    :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:SINCE "1.0.2")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_1_client_method" CL+SSL::SSL-TLSV1-1-CLIENT-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-1-CLIENT-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-1-CLIENT-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_1_client_method" (:POINTER)
;                                    :CONVENTION :CDECL :LIBRARY
;                                    CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:SINCE "1.0.2")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_1_server_method" CL+SSL::SSL-TLSV1-1-SERVER-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-1-SERVER-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-1-SERVER-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_1_server_method" (:POINTER)
;                                    :CONVENTION :CDECL :LIBRARY
;                                    CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:SINCE "1.0.2")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_1_method" CL+SSL::SSL-TLSV1-1-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-1-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-1-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_1_method" (:POINTER) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:SINCE "1.0.2")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_2_client_method" CL+SSL::SSL-TLSV1-2-CLIENT-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-2-CLIENT-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-2-CLIENT-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_2_client_method" (:POINTER)
;                                    :CONVENTION :CDECL :LIBRARY
;                                    CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:SINCE "1.0.2")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_2_server_method" CL+SSL::SSL-TLSV1-2-SERVER-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-2-SERVER-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-2-SERVER-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_2_server_method" (:POINTER)
;                                    :CONVENTION :CDECL :LIBRARY
;                                    CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:SINCE "1.0.2")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_2_method" CL+SSL::SSL-TLSV1-2-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-TLSV1-2-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-TLSV1-2-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLSv1_2_method" (:POINTER) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:SINCE "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.1.0")
;       ("TLS_method" CL+SSL::TLS-METHOD)
;       CL+SSL::SSL-METHOD)
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::TLS-METHOD
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::TLS-METHOD
;         (CFFI-SYS:%FOREIGN-FUNCALL "TLS_method" (:POINTER) :CONVENTION :CDECL
;                                    :LIBRARY CL+SSL/CONFIG::LIBSSL)))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("SSL_CTX_new" SSL-CTX-NEW)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_CTX_new" CL+SSL::SSL-CTX-NEW)
;       CL+SSL::SSL-CTX
;       (METHOD CL+SSL::SSL-METHOD))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-CTX-NEW
;         (METHOD)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-CTX-NEW
;         (LET ((#:G0 METHOD))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_CTX_new" (:POINTER #:G0 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("SSL_new" SSL-NEW)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_new" CL+SSL::SSL-NEW)
;       CL+SSL::SSL-POINTER
;       (CL+SSL::CTX CL+SSL::SSL-CTX))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-NEW
;         (CL+SSL::CTX)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-NEW
;         (LET ((#:G0 CL+SSL::CTX))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_new" (:POINTER #:G0 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("BIO_ctrl" BIO-SET-FD)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("BIO_ctrl" CL+SSL::BIO-SET-FD)
;       :LONG
;       (CL+SSL::BIO :POINTER)
;       (CL+SSL::CMD :INT)
;       (CL+SSL::LARG :LONG)
;       (CL+SSL::PARG :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::BIO-SET-FD
;         (CL+SSL::BIO CL+SSL::CMD CL+SSL::LARG CL+SSL::PARG)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::BIO-SET-FD
;         (LET ((#:G0 CL+SSL::BIO))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("BIO_new_socket" BIO-NEW-SOCKET)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("BIO_new_socket" CL+SSL::BIO-NEW-SOCKET)
;       :POINTER
;       (CL+SSL::FD :INT)
;       (CL+SSL::CLOSE-FLAG :INT))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::BIO-NEW-SOCKET
;         (CL+SSL::FD CL+SSL::CLOSE-FLAG)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::BIO-NEW-SOCKET
;         (LET ((#:G0 CL+SSL::FD))
;           (LET (#)
;             (CFFI-SYS:%FOREIGN-FUNCALL "BIO_new_socket" # :CONVENTION :CDECL
;                                        :LIBRARY CL+SSL/CONFIG::LIBCRYPTO)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("BIO_new" BIO-NEW)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("BIO_new" CL+SSL::BIO-NEW)
;       :POINTER
;       (METHOD :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::BIO-NEW
;         (METHOD)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::BIO-NEW
;         (LET ((#:G0 METHOD))
;           (CFFI-SYS:%FOREIGN-FUNCALL "BIO_new" (:POINTER #:G0 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("BIO_free" BIO-FREE)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("BIO_free" CL+SSL::BIO-FREE)
;       :POINTER
;       (METHOD :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::BIO-FREE
;         (METHOD)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::BIO-FREE
;         (LET ((#:G0 METHOD))
;           (CFFI-SYS:%FOREIGN-FUNCALL "BIO_free" (:POINTER #:G0 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION-EX (:SINCE "1.1.0")
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:SINCE "1.1.0")
;       ("BIO_meth_new" CL+SSL::BIO-METH-NEW)
;       :POINTER
;       (TYPE :INT)
;       (CL+SSL::NAME :STRING))
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::BIO-METH-NEW
;         (TYPE CL+SSL::NAME)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::BIO-METH-NEW
;         (LET ((#:G0 TYPE))
;           (MULTIPLE-VALUE-BIND (#:G1 #:PARAM2)
;               (CFFI:TRANSLATE-TO-FOREIGN CL+SSL::NAME #)
;             (UNWIND-PROTECT # #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("ERR_get_error" ERR-GET-ERROR)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("ERR_get_error" CL+SSL::ERR-GET-ERROR)
;       :UNSIGNED-LONG)
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::ERR-GET-ERROR
;         NIL
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::ERR-GET-ERROR
;         (CFFI-SYS:%FOREIGN-FUNCALL "ERR_get_error" (:UNSIGNED-LONG) :CONVENTION
;                                    :CDECL :LIBRARY CL+SSL/CONFIG::LIBCRYPTO)))
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("ERR_error_string" ERR-ERROR-STRING)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("ERR_error_string" CL+SSL::ERR-ERROR-STRING)
;       :STRING
;       (CL+SSL::E :UNSIGNED-LONG)
;       (CL+SSL::BUF :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA FUNCTION BLOCK LET LET 
; ==>
;   (CFFI:TRANSLATE-FROM-FOREIGN
;    (CFFI-SYS:%FOREIGN-FUNCALL "ERR_error_string"
;                               (:UNSIGNED-LONG #:G0 :POINTER #:G1 :POINTER)
;                               :CONVENTION :CDECL :LIBRARY
;                               CL+SSL/CONFIG::LIBCRYPTO)
;    #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("SSL_CTX_ctrl" SSL-CTX-CTRL)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_CTX_ctrl" CL+SSL::SSL-CTX-CTRL)
;       :LONG
;       (CL+SSL::CTX CL+SSL::SSL-CTX)
;       (CL+SSL::CMD :INT)
;       (CL+SSL::LARG :UNSIGNED-LONG)
;       (CL+SSL::PARG :POINTER))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-CTX-CTRL
;         (CL+SSL::CTX CL+SSL::CMD CL+SSL::LARG CL+SSL::PARG)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-CTX-CTRL
;         (LET ((#:G0 CL+SSL::CTX))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("SSL_ctrl" SSL-CTRL)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_ctrl" CL+SSL::SSL-CTRL)
;       :LONG
;       (CL+SSL::SSL :POINTER)
;       (CL+SSL::CMD :INT)
;       (CL+SSL::LARG :LONG)
;       (CL+SSL::PARG :POINTER))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-CTRL
;         (CL+SSL::SSL CL+SSL::CMD CL+SSL::LARG CL+SSL::PARG)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-CTRL
;         (LET ((#:G0 CL+SSL::SSL))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN SSL-CTX-SET-OPTIONS
;     (CL+SSL::SSL-CTX-CTRL CL+SSL::CTX CL+SSL::+SSL-CTRL-OPTIONS+ CL+SSL::OPTIONS
;      (CFFI-SYS:NULL-POINTER))
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN SSL-CTX-SET-MIN-PROTO-VERSION
;     (CL+SSL::SSL-CTX-CTRL CL+SSL::CTX CL+SSL::+SSL-CTRL-SET-MIN-PROTO-VERSION+
;      CL+SSL::VERSION (CFFI-SYS:NULL-POINTER))
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN SSL-CTX-SET-MAX-PROTO-VERSION
;     (CL+SSL::SSL-CTX-CTRL CL+SSL::CTX CL+SSL::+SSL-CTRL-SET-MAX-PROTO-VERSION+
;      CL+SSL::VERSION (CFFI-SYS:NULL-POINTER))
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in:
;      DEFINE-SSL-FUNCTION ("SSL_load_client_CA_file" SSL-LOAD-CLIENT-CA-FILE)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_load_client_CA_file" CL+SSL::SSL-LOAD-CLIENT-CA-FILE)
;       CL+SSL::SSL-POINTER
;       (CL+SSL::FILE :STRING))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-LOAD-CLIENT-CA-FILE
;         (CL+SSL::FILE)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-LOAD-CLIENT-CA-FILE
;         (MULTIPLE-VALUE-BIND (#:G0 #:PARAM1)
;             (CFFI:TRANSLATE-TO-FOREIGN CL+SSL::FILE
;                                        #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
;           (UNWIND-PROTECT (PROGN #)
;             (CFFI:FREE-TRANSLATED-OBJECT #:G0 # #:PARAM1)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION ("SSL_get_verify_result" SSL-GET-VERIFY-RESULT)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_get_verify_result" CL+SSL::SSL-GET-VERIFY-RESULT)
;       :LONG
;       (CL+SSL::SSL CL+SSL::SSL-POINTER))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-GET-VERIFY-RESULT
;         (CL+SSL::SSL)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-GET-VERIFY-RESULT
;         (LET ((#:G0 CL+SSL::SSL))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_get_verify_result"
;                                      (:POINTER #:G0 :LONG) :CONVENTION :CDECL
;                                      :LIBRARY CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in:
;      DEFINE-SSL-FUNCTION ("SSL_get_peer_certificate" SSL-GET-PEER-CERTIFICATE)
;     (CL+SSL::DEFINE-SSL-FUNCTION
;       ("SSL_get_peer_certificate" CL+SSL::SSL-GET-PEER-CERTIFICATE)
;       :POINTER
;       (CL+SSL::SSL CL+SSL::SSL-POINTER))
; --> CL+SSL::DEFINE-SSL-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-GET-PEER-CERTIFICATE
;         (CL+SSL::SSL)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-GET-PEER-CERTIFICATE
;         (LET ((#:G0 CL+SSL::SSL))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_get_peer_certificate"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("X509_NAME_oneline" X509-NAME-ONELINE)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("X509_NAME_oneline" CL+SSL::X509-NAME-ONELINE)
;       :POINTER
;       (CL+SSL::X509-NAME :POINTER)
;       (CL+SSL::BUF :POINTER)
;       (CL+SSL::SIZE :INT))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-NAME-ONELINE
;         (CL+SSL::X509-NAME CL+SSL::BUF CL+SSL::SIZE)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-NAME-ONELINE
;         (LET ((#:G0 CL+SSL::X509-NAME))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("X509_NAME_get_entry" X509-NAME-GET-ENTRY)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("X509_NAME_get_entry" CL+SSL::X509-NAME-GET-ENTRY)
;       :POINTER
;       (CL+SSL::NAME :POINTER)
;       (LOG :INT))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-NAME-GET-ENTRY
;         (CL+SSL::NAME LOG)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-NAME-GET-ENTRY
;         (LET ((#:G0 CL+SSL::NAME))
;           (LET (#)
;             (CFFI-SYS:%FOREIGN-FUNCALL "X509_NAME_get_entry" # :CONVENTION
;                                        :CDECL :LIBRARY
;                                        CL+SSL/CONFIG::LIBCRYPTO)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in:
;      DEFINE-CRYPTO-FUNCTION ("X509_NAME_ENTRY_get_data" X509-NAME-ENTRY-GET-DATA)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("X509_NAME_ENTRY_get_data" CL+SSL::X509-NAME-ENTRY-GET-DATA)
;       :POINTER
;       (CL+SSL::NAME-ENTRY :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-NAME-ENTRY-GET-DATA
;         (CL+SSL::NAME-ENTRY)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-NAME-ENTRY-GET-DATA
;         (LET ((#:G0 CL+SSL::NAME-ENTRY))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_NAME_ENTRY_get_data"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in:
;      DEFINE-CRYPTO-FUNCTION ("X509_get_issuer_name" X509-GET-ISSUER-NAME)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("X509_get_issuer_name" CL+SSL::X509-GET-ISSUER-NAME)
;       :POINTER
;       (CL+SSL::X509 :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-GET-ISSUER-NAME
;         (CL+SSL::X509)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-GET-ISSUER-NAME
;         (LET ((#:G0 CL+SSL::X509))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_get_issuer_name"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in:
;      DEFINE-CRYPTO-FUNCTION ("X509_get_subject_name" X509-GET-SUBJECT-NAME)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("X509_get_subject_name" CL+SSL::X509-GET-SUBJECT-NAME)
;       :POINTER
;       (CL+SSL::X509 :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-GET-SUBJECT-NAME
;         (CL+SSL::X509)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-GET-SUBJECT-NAME
;         (LET ((#:G0 CL+SSL::X509))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_get_subject_name"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION-EX (:SINCE "1.1.0")
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:SINCE "1.1.0")
;       ("X509_get0_notBefore" CL+SSL::X509-GET0-NOT-BEFORE)
;       :POINTER
;       (CL+SSL::X509 :POINTER))
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-GET0-NOT-BEFORE
;         (CL+SSL::X509)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-GET0-NOT-BEFORE
;         (LET ((#:G0 CL+SSL::X509))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_get0_notBefore"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION-EX (:SINCE "1.1.0")
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:SINCE "1.1.0")
;       ("X509_get0_notAfter" CL+SSL::X509-GET0-NOT-AFTER)
;       :POINTER
;       (CL+SSL::X509 :POINTER))
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-GET0-NOT-AFTER
;         (CL+SSL::X509)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-GET0-NOT-AFTER
;         (LET ((#:G0 CL+SSL::X509))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_get0_notAfter"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("X509_get_ext_d2i" X509-GET-EXT-D2I)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("X509_get_ext_d2i" CL+SSL::X509-GET-EXT-D2I)
;       :POINTER
;       (CL+SSL::CERT :POINTER)
;       (CL+SSL::NID :INT)
;       (CL+SSL::CRIT :POINTER)
;       (CL+SSL::IDX :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::X509-GET-EXT-D2I
;         (CL+SSL::CERT CL+SSL::NID CL+SSL::CRIT CL+SSL::IDX)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::X509-GET-EXT-D2I
;         (LET ((#:G0 CL+SSL::CERT))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("d2i_X509" D2I-X509)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("d2i_X509" CL+SSL::D2I-X509)
;       :POINTER
;       (CL+SSL::*PX :POINTER)
;       (CL+SSL::IN :POINTER)
;       (CL+SSL::LEN :INT))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::D2I-X509
;         (CL+SSL::*PX CL+SSL::IN CL+SSL::LEN)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::D2I-X509
;         (LET ((#:G0 CL+SSL::*PX))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("PEM_read_bio_X509" PEM-READ-X509)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("PEM_read_bio_X509" CL+SSL::PEM-READ-X509)
;       :POINTER
;       (CL+SSL::BIO :POINTER)
;       (CL+SSL::X509 :INT)
;       (CL+SSL::CALLBACK :INT)
;       (CL+SSL::PASSPHRASE :INT))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::PEM-READ-X509
;         (CL+SSL::BIO CL+SSL::X509 CL+SSL::CALLBACK CL+SSL::PASSPHRASE)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::PEM-READ-X509
;         (LET ((#:G0 CL+SSL::BIO))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in:
;      DEFINE-CRYPTO-FUNCTION ("EVP_get_digestbyname" EVP-GET-DIGEST-BY-NAME)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("EVP_get_digestbyname" CL+SSL::EVP-GET-DIGEST-BY-NAME)
;       :POINTER
;       (CL+SSL::NAME :STRING))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::EVP-GET-DIGEST-BY-NAME
;         (CL+SSL::NAME)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::EVP-GET-DIGEST-BY-NAME
;         (MULTIPLE-VALUE-BIND (#:G0 #:PARAM1)
;             (CFFI:TRANSLATE-TO-FOREIGN CL+SSL::NAME
;                                        #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
;           (UNWIND-PROTECT (PROGN #)
;             (CFFI:FREE-TRANSLATED-OBJECT #:G0 # #:PARAM1)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("sk_value" CL+SSL::SK-VALUE)
;       :POINTER
;       (CL+SSL::STACK :POINTER)
;       (CL+SSL::INDEX :INT))
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SK-VALUE
;         (CL+SSL::STACK CL+SSL::INDEX)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SK-VALUE
;         (LET ((#:G0 CL+SSL::STACK))
;           (LET (#)
;             (CFFI-SYS:%FOREIGN-FUNCALL "sk_value" # :CONVENTION :CDECL :LIBRARY
;                                        CL+SSL/CONFIG::LIBCRYPTO)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION-EX (:SINCE "1.1.0")
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:SINCE "1.1.0")
;       ("OPENSSL_sk_value" CL+SSL::OPENSSL-SK-VALUE)
;       :POINTER
;       (CL+SSL::STACK :POINTER)
;       (CL+SSL::INDEX :INT))
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::OPENSSL-SK-VALUE
;         (CL+SSL::STACK CL+SSL::INDEX)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::OPENSSL-SK-VALUE
;         (LET ((#:G0 CL+SSL::STACK))
;           (LET (#)
;             (CFFI-SYS:%FOREIGN-FUNCALL "OPENSSL_sk_value" # :CONVENTION :CDECL
;                                        :LIBRARY CL+SSL/CONFIG::LIBCRYPTO)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN SK-GENERAL-NAME-VALUE
;     (DEFUN CL+SSL::SK-GENERAL-NAME-VALUE (CL+SSL::NAMES CL+SSL::INDEX)
;       (IF (AND (NOT (CL+SSL::LIBRESSLP)) (CL+SSL::OPENSSL-IS-AT-LEAST 1 1))
;           (CL+SSL::OPENSSL-SK-VALUE CL+SSL::NAMES CL+SSL::INDEX)
;           (CL+SSL::SK-VALUE CL+SSL::NAMES CL+SSL::INDEX)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SK-GENERAL-NAME-VALUE
;         (CL+SSL::NAMES CL+SSL::INDEX)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SK-GENERAL-NAME-VALUE
;         (IF (AND (NOT #) (CL+SSL::OPENSSL-IS-AT-LEAST 1 1))
;             (CL+SSL::OPENSSL-SK-VALUE CL+SSL::NAMES CL+SSL::INDEX)
;             (CL+SSL::SK-VALUE CL+SSL::NAMES CL+SSL::INDEX))))
; 
; note: Type assertion too complex to check:
; (VALUES SB-SYS:SYSTEM-AREA-POINTER &REST T).
; It allows an unknown number of values, consider using
; (VALUES SB-SYS:SYSTEM-AREA-POINTER &OPTIONAL).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN SK-GENERAL-NAME-NUM
;     (DEFUN CL+SSL::SK-GENERAL-NAME-NUM (CL+SSL::NAMES)
;       (IF (AND (NOT (CL+SSL::LIBRESSLP)) (CL+SSL::OPENSSL-IS-AT-LEAST 1 1))
;           (CL+SSL::OPENSSL-SK-NUM CL+SSL::NAMES)
;           (CL+SSL::SK-NUM CL+SSL::NAMES)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SK-GENERAL-NAME-NUM
;         (CL+SSL::NAMES)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SK-GENERAL-NAME-NUM
;         (IF (AND (NOT #) (CL+SSL::OPENSSL-IS-AT-LEAST 1 1))
;             (CL+SSL::OPENSSL-SK-NUM CL+SSL::NAMES)
;             (CL+SSL::SK-NUM CL+SSL::NAMES))))
; 
; note: Type assertion too complex to check:
; (VALUES FIXNUM &REST T).
; It allows an unknown number of values, consider using
; (VALUES FIXNUM &OPTIONAL).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("ASN1_STRING_data" ASN1-STRING-DATA)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("ASN1_STRING_data" CL+SSL::ASN1-STRING-DATA)
;       :POINTER
;       (CL+SSL::ASN1-STRING :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::ASN1-STRING-DATA
;         (CL+SSL::ASN1-STRING)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::ASN1-STRING-DATA
;         (LET ((#:G0 CL+SSL::ASN1-STRING))
;           (CFFI-SYS:%FOREIGN-FUNCALL "ASN1_STRING_data"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-CRYPTO-FUNCTION ("RSA_generate_key" RSA-GENERATE-KEY)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("RSA_generate_key" CL+SSL::RSA-GENERATE-KEY)
;       :POINTER
;       (CL+SSL::NUM :INT)
;       (CL+SSL::E :UNSIGNED-LONG)
;       (CL+SSL::CALLBACK :POINTER)
;       (CL+SSL::OPT :POINTER))
; --> CL+SSL::DEFINE-CRYPTO-FUNCTION-EX PROGN CL+SSL::DEFCFUN-VERSIONED 
; --> CFFI:DEFCFUN PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::RSA-GENERATE-KEY
;         (CL+SSL::NUM CL+SSL::E CL+SSL::CALLBACK CL+SSL::OPT)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::RSA-GENERATE-KEY
;         (LET ((#:G0 CL+SSL::NUM))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "1.1.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSL_CTX_set_tmp_rsa_callback" CL+SSL::SSL-CTX-SET-TMP-RSA-CALLBACK)
;       :POINTER
;       (CL+SSL::CTX :POINTER)
;       (CL+SSL::CALLBACK :POINTER))
; --> PROGN CL+SSL::DEFCFUN-VERSIONED CFFI:DEFCFUN PROGN DEFUN PROGN 
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CL+SSL::SSL-CTX-SET-TMP-RSA-CALLBACK
;         (CL+SSL::CTX CL+SSL::CALLBACK)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-CTX-SET-TMP-RSA-CALLBACK
;         (LET ((#:G0 CL+SSL::CTX))
;           (LET (#)
;             (CFFI-SYS:%FOREIGN-FUNCALL "SSL_CTX_set_tmp_rsa_callback" #
;                                        :CONVENTION :CDECL :LIBRARY
;                                        CL+SSL/CONFIG::LIBSSL)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: CFFI:DEFCALLBACK TMP-RSA-CALLBACK
;     (= CL+SSL::KEY-LENGTH 512)
; 
; 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.

;     (= CL+SSL::KEY-LENGTH 1024)
; 
; 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.

;     (CL+SSL::RSA-GENERATE-KEY LENGTH CL+SSL::+RSA_F4+ (CFFI-SYS:NULL-POINTER)
;      (CFFI-SYS:NULL-POINTER))
; 
; note: doing SAP to pointer coercion (cost 20)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN ENSURE-SSL-FUNCALL
;     (APPLY CL+SSL::FUNC CL+SSL::ARGS)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNC is not known to be a function

;     (PLUSP CL+SSL::NBYTES)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN NONBLOCKING-SSL-FUNCALL
;     (APPLY CL+SSL::FUNC CL+SSL::ARGS)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNC is not known to be a function

;     (PLUSP CL+SSL::NBYTES)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN SECONDS-UNTIL-DEADLINE
;     (- CL+SSL::DEADLINE (GET-INTERNAL-REAL-TIME))
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).

;     (/ (- CL+SSL::DEADLINE (GET-INTERNAL-REAL-TIME))
;        INTERNAL-TIME-UNITS-PER-SECOND)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (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.

;     (- CL+SSL::DEADLINE (GET-INTERNAL-REAL-TIME))
; 
; note: forced to do GENERIC-- (cost 10)
;       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).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: CFFI:DEFCALLBACK PEM-PASSWORD-CALLBACK
;     (COERCE CL+SSL::*PEM-PASSWORD* 'BASE-STRING)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR LIST (AND (NOT BASE-STRING) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR LIST (AND (NOT BASE-STRING) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY * (*)).
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR LIST (AND (NOT BASE-STRING) VECTOR) SB-KERNEL:EXTENDED-SEQUENCE), not a (SIMPLE-ARRAY CHARACTER (*)).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN INIT-PRNG
;     (LENGTH CL+SSL::SEED-BYTE-SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (ELT CL+SSL::SEED-BYTE-SEQUENCE CL+SSL::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.

;     (CL+SSL::RAND-SEED CL+SSL::PTR LENGTH)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN SSL-CTX-SET-SESSION-CACHE-MODE
;     (CL+SSL::SSL-CTX-CTRL CL+SSL::CTX CL+SSL::+SSL_CTRL_SET_SESS_CACHE_MODE+
;      CL+SSL::MODE (CFFI-SYS:NULL-POINTER))
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: CFFI:DEFCALLBACK LOCKING-CALLBACK
;     (ELT CL+SSL::*LOCKS* CL+SSL::N)
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: CFFI:DEFCALLBACK THREADID-CALLBACK
;     (INCF CL+SSL::*THREAD-COUNTER*)
; --> SETQ THE 
; ==>
;   (+ 1 CL+SSL::*THREAD-COUNTER*)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/ffi.lisp
; in: DEFUN INITIALIZE
;     (FUNCALL (OR METHOD (CL+SSL::DEFAULT-SSL-METHOD)))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD PRINT-OBJECT (SSL-STREAM T)
;     (FORMAT STREAM "for ~A" (CL+SSL::SSL-STREAM-SOCKET CL+SSL::OBJECT))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STRING BOOLEAN STREAM), not a STREAM.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STRING BOOLEAN STREAM), not a (MEMBER T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STRING BOOLEAN STREAM), not a NULL.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD CLOSE (SSL-STREAM)
;     (FUNCALL (CL+SSL::SSL-CLOSE-CALLBACK STREAM))
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: callable expression is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD STREAM-LISTEN (SSL-STREAM)
;     (CL+SSL::BUFFER-ELT CL+SSL::BUF 0)
; --> BLOCK 
; ==>
;   (ELT CL+SSL::BUF CL+SSL::INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD STREAM-READ-BYTE (SSL-STREAM)
;     (CL+SSL::BUFFER-ELT CL+SSL::BUF 0)
; --> BLOCK 
; ==>
;   (ELT CL+SSL::BUF CL+SSL::INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD STREAM-READ-SEQUENCE (SSL-STREAM T T T)
;     (- CL+SSL::END CL+SSL::START)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a RATIONAL.The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a RATIONAL.The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

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

;     (< CL+SSL::START CL+SSL::END)
; 
; note: unable to open-code float conversion in mixed numeric operation 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 open-code float conversion in mixed numeric operation 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.

;     (SETF (ELT CL+SSL::SEQ CL+SSL::START) (CL+SSL::SSL-STREAM-PEEKED-BYTE STREAM))
; ==>
;   (SB-KERNEL:%SETELT CL+SSL::SEQ CL+SSL::START
;                      (CL+SSL::SSL-STREAM-PEEKED-BYTE STREAM))
; 
; 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.

;     (+ CL+SSL::START CL+SSL::READ-BYTES)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).

;     (CL+SSL::BUFFER-LENGTH CL+SSL::BUF)
; --> BLOCK 
; ==>
;   (LENGTH CL+SSL::BUF)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (CL+SSL::S/B-REPLACE CL+SSL::SEQ CL+SSL::BUF :START1 CL+SSL::START :END1
;                          (+ CL+SSL::START CL+SSL::READ-BYTES))
; --> BLOCK 
; ==>
;   (REPLACE CL+SSL::SEQ CL+SSL::BUF :START1 CL+SSL::START1 :END1 CL+SSL::END1
;            :START2 CL+SSL::START2 :END2 CL+SSL::END2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.The second argument is a (OR (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-STRING (SIMPLE-ARRAY CHARACTER (*)) (SIMPLE-ARRAY SINGLE-FLOAT (*)) (SIMPLE-ARRAY DOUBLE-FLOAT (*)) SIMPLE-BIT-VECTOR (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 62) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 63) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*)) (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)) (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)) (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)) (SIMPLE-ARRAY FIXNUM (*)) (SIMPLE-ARRAY (SIGNED-BYTE 64) (*)) (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT) (*)) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*))), not a (SIMPLE-ARRAY CHARACTER (*)).The result is a (VALUES SEQUENCE &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 second argument is a (OR (SIMPLE-ARRAY NIL (*)) SIMPLE-BASE-STRING (SIMPLE-ARRAY CHARACTER (*)) (SIMPLE-ARRAY SINGLE-FLOAT (*)) (SIMPLE-ARRAY DOUBLE-FLOAT (*)) SIMPLE-BIT-VECTOR (SIMPLE-ARRAY (UNSIGNED-BYTE 2) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 4) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 7) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 8) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 15) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 16) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 31) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 32) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 62) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 63) (*)) (SIMPLE-ARRAY (UNSIGNED-BYTE 64) (*)) (SIMPLE-ARRAY (SIGNED-BYTE 8) (*)) (SIMPLE-ARRAY (SIGNED-BYTE 16) (*)) (SIMPLE-ARRAY (SIGNED-BYTE 32) (*)) (SIMPLE-ARRAY FIXNUM (*)) (SIMPLE-ARRAY (SIGNED-BYTE 64) (*)) (SIMPLE-ARRAY (COMPLEX SINGLE-FLOAT) (*)) (SIMPLE-ARRAY (COMPLEX DOUBLE-FLOAT) (*))), not a SIMPLE-BASE-STRING.The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES (SIMPLE-ARRAY CHARACTER (*)) &REST T).

;     (MIN (- CL+SSL::END CL+SSL::START) (CL+SSL::BUFFER-LENGTH CL+SSL::BUF))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; 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.

;     (< CL+SSL::START CL+SSL::END)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.

;     (- CL+SSL::END CL+SSL::START)
; 
; 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 T, 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 REAL, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (MIN (- CL+SSL::END CL+SSL::START) (CL+SSL::BUFFER-LENGTH CL+SSL::BUF))
; 
; 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.

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

;     (+ CL+SSL::START CL+SSL::READ-BYTES)
; 
; 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 inline (signed-byte 64) arithmetic (cost 4) because:
;       The first 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.

;     (INCF CL+SSL::START CL+SSL::READ-BYTES)
; ==>
;   (SETQ CL+SSL::START (+ CL+SSL::READ-BYTES CL+SSL::START))
; 
; note: doing signed word to integer coercion (cost 20) to START

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD STREAM-WRITE-BYTE (SSL-STREAM T)
;     (INCF (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM))
; --> LET* 
; ==>
;   (+ 1 (CL+SSL::SSL-STREAM-OUTPUT-POINTER #:STREAM4))
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (CL+SSL::BUFFER-LENGTH CL+SSL::BUF)
; --> BLOCK 
; ==>
;   (LENGTH CL+SSL::BUF)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (SETF (CL+SSL::BUFFER-ELT CL+SSL::BUF
;                               (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM))
;             CL+SSL::B)
; --> CL+SSL::SET-BUFFER-ELT BLOCK SETF 
; ==>
;   (SB-KERNEL:%SETELT CL+SSL::BUF CL+SSL::INDEX CL+SSL::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 LIST.

;     (INCF (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM))
; --> LET* 
; ==>
;   (+ 1 (CL+SSL::SSL-STREAM-OUTPUT-POINTER #:STREAM4))
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD STREAM-WRITE-SEQUENCE (SSL-STREAM T T T)
;     (- CL+SSL::END CL+SSL::START)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (+ (- CL+SSL::END CL+SSL::START) (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM))
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (>
;      (+ (- CL+SSL::END CL+SSL::START) (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM))
;      (CL+SSL::BUFFER-LENGTH CL+SSL::BUF))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (- CL+SSL::END CL+SSL::START)
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a SINGLE-FLOAT.

;     (CL+SSL::BUFFER-LENGTH CL+SSL::BUF)
; --> BLOCK 
; ==>
;   (LENGTH CL+SSL::BUF)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (> (- CL+SSL::END CL+SSL::START) (CL+SSL::BUFFER-LENGTH CL+SSL::BUF))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (CL+SSL::BUFFER-LENGTH CL+SSL::BUF)
; --> BLOCK 
; ==>
;   (LENGTH CL+SSL::BUF)
; 
; 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 VECTOR.

;     (CL+SSL::B/S-REPLACE CL+SSL::BUF CL+SSL::SEQ :START1
;                          (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM) :START2
;                          CL+SSL::START :END2 CL+SSL::END)
; --> BLOCK 
; ==>
;   (REPLACE CL+SSL::BUF CL+SSL::SEQ :START1 CL+SSL::START1 :END1 CL+SSL::END1
;            :START2 CL+SSL::START2 :END2 CL+SSL::END2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).The second argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.The second argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).The result is a (VALUES SEQUENCE &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 second argument is a SEQUENCE, not a SIMPLE-BASE-STRING.The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES (SIMPLE-ARRAY CHARACTER (*)) &REST T).

;     (INCF (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM)
;           (- CL+SSL::END CL+SSL::START))
; --> LET* 
; ==>
;   (+ (- CL+SSL::END CL+SSL::START)
;      (CL+SSL::SSL-STREAM-OUTPUT-POINTER #:STREAM28))
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The second argument is a NUMBER, not a FLOAT.
; 
; note: unable to open-code float conversion in mixed numeric operation due to type uncertainty: The second argument is a NUMBER, not a (OR (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)).

;     (CL+SSL::BUFFER-LENGTH CL+SSL::BUF)
; --> BLOCK 
; ==>
;   (LENGTH CL+SSL::BUF)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (CL+SSL::B/S-REPLACE CL+SSL::BUF CL+SSL::SEQ :START2 CL+SSL::START)
; --> BLOCK 
; ==>
;   (REPLACE CL+SSL::BUF CL+SSL::SEQ :START1 CL+SSL::START1 :END1 CL+SSL::END1
;            :START2 CL+SSL::START2 :END2 CL+SSL::END2)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).The second argument is a SEQUENCE, not a (SIMPLE-ARRAY * (*)).The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES (SIMPLE-ARRAY * (*)) &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a SIMPLE-BASE-STRING.The second argument is a SEQUENCE, not a (SIMPLE-ARRAY CHARACTER (*)).The result is a (VALUES SEQUENCE &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 second argument is a SEQUENCE, not a SIMPLE-BASE-STRING.The result is a (VALUES SEQUENCE &OPTIONAL), not a (VALUES (SIMPLE-ARRAY CHARACTER (*)) &REST T).

;     (- CL+SSL::END CL+SSL::START)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a T, 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 T, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ (- CL+SSL::END CL+SSL::START) (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM))
; 
; 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 T, 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 T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (>
;      (+ (- CL+SSL::END CL+SSL::START) (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM))
;      (CL+SSL::BUFFER-LENGTH CL+SSL::BUF))
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.

;     (- CL+SSL::END CL+SSL::START)
; 
; 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.

;     (> (- CL+SSL::END CL+SSL::START) (CL+SSL::BUFFER-LENGTH CL+SSL::BUF))
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a NUMBER, not a FIXNUM.

;     (INCF (CL+SSL::SSL-STREAM-OUTPUT-POINTER STREAM)
;           (- CL+SSL::END CL+SSL::START))
; --> LET* 
; ==>
;   (+ (- CL+SSL::END CL+SSL::START)
;      (CL+SSL::SSL-STREAM-OUTPUT-POINTER #:STREAM28))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a T, 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 T, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (INCF CL+SSL::START (CL+SSL::BUFFER-LENGTH CL+SSL::BUF))
; ==>
;   (SETQ CL+SSL::START (+ (CL+SSL::BUFFER-LENGTH CL+SSL::BUF) CL+SSL::START))
; 
; note: doing signed word to integer coercion (cost 20) to START

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFMETHOD STREAM-FORCE-OUTPUT (SSL-STREAM)
;     (PLUSP CL+SSL::FILL-PTR)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFUN X509-CERTIFICATE-NAMES
;     (CFFI-SYS:WITH-FOREIGN-POINTER (CL+SSL::BUF 1024)
;       (LET ((CL+SSL::ISSUER-NAME
;              (CL+SSL::X509-GET-ISSUER-NAME CL+SSL::X509-CERTIFICATE))
;             (CL+SSL::SUBJECT-NAME
;              (CL+SSL::X509-GET-SUBJECT-NAME CL+SSL::X509-CERTIFICATE)))
;         (VALUES
;          (UNLESS (CFFI-SYS:NULL-POINTER-P CL+SSL::ISSUER-NAME)
;            (CL+SSL::X509-NAME-ONELINE CL+SSL::ISSUER-NAME CL+SSL::BUF 1024)
;            (CFFI:FOREIGN-STRING-TO-LISP CL+SSL::BUF))
;          (UNLESS (CFFI-SYS:NULL-POINTER-P CL+SSL::SUBJECT-NAME)
;            (CL+SSL::X509-NAME-ONELINE CL+SSL::SUBJECT-NAME CL+SSL::BUF 1024)
;            (CFFI:FOREIGN-STRING-TO-LISP CL+SSL::BUF)))))
; --> WITH-ALIEN SYMBOL-MACROLET SYMBOL-MACROLET LET LET 
; ==>
;   (SB-ALIEN-INTERNALS:MAKE-LOCAL-ALIEN
;    '#<SB-ALIEN-INTERNALS:LOCAL-ALIEN-INFO (forced to stack) (ARRAY (UNSIGNED 8)
;                                                              1024)>)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the first result of ALLOC-ALIEN-STACK-SPACE

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFUN SSL-LOAD-GLOBAL-VERIFY-LOCATIONS
;     (CL+SSL::SSL-CTX-LOAD-VERIFY-LOCATIONS CL+SSL::*SSL-GLOBAL-CONTEXT*
;                                            CL+SSL::CAFILE (CFFI-SYS:NULL-POINTER))
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFUN MAKE-SSL-CLIENT-STREAM
;     (ZEROP (CL+SSL::SSL-SET-CIPHER-LIST CL+SSL::HANDLE CL+SSL::CIPHER-LIST))
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/acbfafa5e3cc0f29767785ad861d8f26aad2122b/cl+ssl-20211013-git/src/streams.lisp
; in: DEFUN MAKE-SSL-SERVER-STREAM
;     (ZEROP (CL+SSL::SSL-SET-CIPHER-LIST CL+SSL::HANDLE CL+SSL::CIPHER-LIST))
; 
; 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.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/drakma/d93281e7b17e2928b082c9c9ccba5c8162baefc6/drakma-v2.0.8/util.lisp
; in: DEFUN USER-AGENT-STRING
;     (OR (LISP-IMPLEMENTATION-TYPE) "Common Lisp")
; --> LET IF 
; ==>
;   "Common Lisp"
; 
; note: deleting unreachable code

;     (OR (LISP-IMPLEMENTATION-VERSION) "")
; --> LET IF 
; ==>
;   ""
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/drakma/d93281e7b17e2928b082c9c9ccba5c8162baefc6/drakma-v2.0.8/util.lisp
; in: DEFUN INTERPRET-AS-TIME-ZONE
;     (CL-PPCRE:REGISTER-GROUPS-BIND (DRAKMA::SIGN DRAKMA::HOURS DRAKMA::MINUTES)
;         ("(?:GMT|)\\s*([+-]?)(\\d\\d):?(\\d\\d)" STRING)
;       (*
;        (IF (EQUAL DRAKMA::SIGN "-")
;            1
;            -1)
;        (+ (PARSE-INTEGER DRAKMA::HOURS) (/ (PARSE-INTEGER DRAKMA::MINUTES) 60))))
; --> LET MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION WHEN IF LET* LET IF 
; ==>
;   NIL
; 
; caught STYLE-WARNING:
;   This is not a STRING:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
; 
; caught STYLE-WARNING:
;   This is not a STRING:
;    NIL
;   See also:
;     The SBCL Manual, Node "Handling of Types"
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "drakma" "util">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/adw-charting/7a7e66124521f356ff6b6b9653f8b190b827b7e1/adw-charting-20211013-http/src/charting.lisp
; in: DEFCLASS AREA
;     (NET.ACCELERATION.CHARTING::HEIGHT :ACCESSOR
;      NET.ACCELERATION.CHARTING::HEIGHT :INITARG :HEIGHT :TYPE INTEGER :INITFORM
;      NIL)
; ==>
;   (SB-KERNEL:THE* (INTEGER :SOURCE-FORM NIL :USE-ANNOTATIONS T) NIL)
; 
; caught WARNING:
;   Constant NIL conflicts with its asserted type INTEGER.
;   See also:
;     The SBCL Manual, Node "Handling of Types"

;     (NET.ACCELERATION.CHARTING::WIDTH :ACCESSOR NET.ACCELERATION.CHARTING::WIDTH
;      :INITARG :WIDTH :TYPE INTEGER :INITFORM NIL)
; ==>
;   (SB-KERNEL:THE* (INTEGER :SOURCE-FORM NIL :USE-ANNOTATIONS T) NIL)
; 
; caught WARNING:
;   Constant NIL conflicts with its asserted type INTEGER.
;   See also:
;     The SBCL Manual, Node "Handling of Types"
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1001BF0103}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "adw-charting" "src" "charting">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1001BF0103}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {102755BC43}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {102755BC43}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {102755BC43}>)
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 "adw-charting" "src" "charting">)))
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 "adw-charting" "src" "charting">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "adw-charting" "src" "charting">)
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 "adw-charting" "src" "charting">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {10058AE853}>) [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 {10058AE853}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "adw-charting-google"> :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 "adw-charting-google">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "adw-charting-google">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "adw-charting-google")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "adw-charting-google") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10058A752B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005869B5B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "adw-charting-google") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "adw-charting-google" "adw-charting-google")
23: (DEPCHECK::MAGIC "adw-charting-google" "adw-charting-google" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-eLD0jEcq/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "adw-charting-google" "adw-charting-google" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-eLD0jEcq/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-eLD0jEcq/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-1" :IN SB-IMPL::START-LISP))
28: (SB-IMPL::START-LISP)

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