adw-charting

adw-charting-google

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20250708-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 optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (+ 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEF-*-TO-BASE64-* :STRING
;     (CL-BASE64::DEF-*-TO-BASE64-* :STRING :STRING)
; --> 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 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 
; --> + 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

;     (CL-BASE64::DEF-*-TO-BASE64-* :STRING :STREAM)
; --> 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 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

; --> 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 
; --> + 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.

; in: DEF-*-TO-BASE64-* :USB8-ARRAY
;     (CL-BASE64::DEF-*-TO-BASE64-* :USB8-ARRAY :STRING)
; --> 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 
; ==>
;   1
; 
; note: unable to optimize 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.

; --> 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 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; --> + 
; ==>
;   1
; 
; note: unable to optimize 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 optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

;     (CL-BASE64::DEF-*-TO-BASE64-* :USB8-ARRAY :STREAM)
; --> 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 
; ==>
;   1
; 
; note: unable to optimize 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.

; --> 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 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; --> 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 
; --> + 
; ==>
;   1
; 
; note: unable to optimize 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 optimize due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 8)), not a SIMPLE-ARRAY.

; 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 optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (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 SINGLE-FLOAT.
; 
; 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 DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (/ CL-BASE64::PADDING-BITS 6)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.The result is a (VALUES (OR FLOAT (RATIONAL 0 4)) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; 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) 6)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.The result is a (VALUES REAL &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; 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 optimize due to type uncertainty: The first argument is a (RATIONAL 0 24), not a INTEGER.The result is a (VALUES (RATIONAL 0 8) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (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.

;     (- 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) 24)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; 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 second argument is a (RATIONAL 0 24), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a REAL, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL 0 24), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* CL-BASE64::COLUMNS (TRUNCATE CL-BASE64::PADDED-LENGTH CL-BASE64::COLUMNS))
; 
; note: forced to do */SIGNED=>INTEGER (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The result is a (VALUES (INTEGER -21267647932558653961849226946058125312 21267647932558653957237540927630737409) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER -21267647932558653961849226946058125312 21267647932558653957237540927630737409) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER -21267647932558653961849226946058125312 21267647932558653957237540927630737409), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER -21267647932558653961849226946058125313 21267647932558653966460912964485513215) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       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 (RATIONAL 0 8), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL 0 8), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; 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 optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to convert division by 2^k to shift due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (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 SINGLE-FLOAT.
; 
; 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 DOUBLE-FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

;     (/ CL-BASE64::PADDING-BITS 6)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR FLOAT (RATIONAL 0 24)), not a INTEGER.The result is a (VALUES (OR FLOAT (RATIONAL 0 4)) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; 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) 6)
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.The result is a (VALUES REAL &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; 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 optimize due to type uncertainty: The first argument is a (RATIONAL 0 24), not a INTEGER.The result is a (VALUES (RATIONAL 0 8) &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; note: unable to convert x/2^k to shift due to type uncertainty: The first argument is a (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.

;     (- 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a (OR FLOAT (RATIONAL 0 (24))), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR FLOAT (RATIONAL (0) 24)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ CL-BASE64::PADDED-BITS CL-BASE64::PADDING-BITS)
; 
; 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 second argument is a (OR FLOAT (RATIONAL 0 24)), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a FIXNUM, not a (UNSIGNED-BYTE 64).
;       The second argument is a (OR FLOAT (RATIONAL 0 4)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (OR FLOAT (RATIONAL -4611686018427387908 4611686018427387903)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       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 &OPTIONAL).
;       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 &OPTIONAL).
;       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 (RATIONAL 0 8), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a (RATIONAL 0 8), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-base64/f995d12a8885d3738a7ddea4ea8ef00ca8c88a2a/cl-base64-20250708-git/decode.lisp
; in: DEFINE-BASE64-DECODER :STRING
;     (CL-BASE64::DEFINE-BASE64-DECODER :STRING :INTEGER)
; --> 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 
; --> COND IF IF 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 (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> 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 
; --> COND IF IF 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 (OR (INTEGER 0 0) (INTEGER 256)), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 256)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; --> 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 
; --> COND IF IF IF 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 (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> 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 
; --> COND IF IF IF 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 (OR (INTEGER 0 0) (INTEGER 256)), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 256)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; --> 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 
; --> COND IF 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 (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> 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 
; --> COND IF 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 (OR (INTEGER 0 0) (INTEGER 256)), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 256)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFINE-BASE64-DECODER :STREAM
;     (CL-BASE64::DEFINE-BASE64-DECODER :STREAM :INTEGER)
; --> 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 (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER 0 0) (INTEGER 256)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; --> 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 (OR (INTEGER 0 0) (INTEGER 256)), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 256)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/chunga/27318fdd31e711689e5441457be7306581dfe92c/chunga-20250708-git/known-words.lisp
; in: DEFUN AS-KEYWORD-IF-FOUND
;     (CHUNGA::DESTRUCTIVEP T)
; 
; caught STYLE-WARNING:
;   The variable DESTRUCTIVEP is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "chunga" "known-words">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/chunga/27318fdd31e711689e5441457be7306581dfe92c/chunga-20250708-git/read.lisp
; in: DEFUN TRIM-WHITESPACE
;     (CHAR STRING CHUNGA::I)
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
; 
; note: unable to optimize due to type uncertainty: The first argument is a STRING, not a SIMPLE-ARRAY.
WARNING: redefining UIOP/PACKAGE:FIND-PACKAGE* in DEFUN
WARNING: redefining UIOP/PACKAGE:FIND-SYMBOL* in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-CALL in DEFUN
WARNING: redefining UIOP/PACKAGE:INTERN* in DEFUN
WARNING: redefining UIOP/PACKAGE:EXPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:IMPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:SHADOWING-IMPORT* in DEFUN
WARNING: redefining UIOP/PACKAGE:SHADOW* in DEFUN
WARNING: redefining UIOP/PACKAGE:MAKE-SYMBOL* in DEFUN
WARNING: redefining UIOP/PACKAGE:UNINTERN* in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-SHADOWING-P in DEFUN
WARNING: redefining UIOP/PACKAGE:HOME-PACKAGE-P in DEFUN
WARNING: redefining UIOP/PACKAGE:SYMBOL-PACKAGE-NAME in DEFUN
WARNING: redefining UIOP/PACKAGE:STANDARD-COMMON-LISP-SYMBOL-P in DEFUN
WARNING: redefining UIOP/PACKAGE:REIFY-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:UNREIFY-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:REIFY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:UNREIFY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::RECORD-FISHY in DEFUN
WARNING: redefining UIOP/PACKAGE::WHEN-PACKAGE-FISHINESS in DEFMACRO
WARNING: redefining UIOP/PACKAGE::NOTE-PACKAGE-FISHINESS in DEFMACRO
WARNING: redefining UIOP/PACKAGE::SET-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::MAKE-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::GET-DUMMY-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:NUKE-SYMBOL-IN-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:NUKE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:REHOME-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE:ENSURE-PACKAGE-UNUSED in DEFUN
WARNING: redefining UIOP/PACKAGE:DELETE-PACKAGE* in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGE-NAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGES-FROM-NAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:FRESH-PACKAGE-NAME in DEFUN
WARNING: redefining UIOP/PACKAGE:RENAME-PACKAGE-AWAY in DEFUN
WARNING: redefining UIOP/PACKAGE:PACKAGE-DEFINITION-FORM in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-SHADOWING-IMPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-IMPORTED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-IMPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-INHERITED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-MIX in DEFUN
WARNING: redefining UIOP/PACKAGE::RECYCLE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::SYMBOL-RECYCLED-P in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-SYMBOL in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORTED-TO-USER in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORTED in DEFUN
WARNING: redefining UIOP/PACKAGE::ENSURE-EXPORT in DEFUN
WARNING: redefining UIOP/PACKAGE::INSTALL-PACKAGE-LOCAL-NICKNAMES in DEFUN
WARNING: redefining UIOP/PACKAGE:ENSURE-PACKAGE in DEFUN
WARNING: redefining UIOP/PACKAGE:PARSE-DEFINE-PACKAGE-FORM in DEFUN
WARNING: redefining UIOP/PACKAGE:DEFINE-PACKAGE in DEFMACRO
WARNING: redefining UIOP/COMMON-LISP::FROB-SUBSTRINGS in DEFUN
WARNING: redefining UIOP/COMMON-LISP::COMPATFMT in DEFMACRO
WARNING: redefining UIOP/UTILITY::ENSURE-FUNCTION-NOTINLINE in DEFUN
WARNING: redefining UIOP/UTILITY:WITH-UPGRADABILITY in DEFMACRO
WARNING: redefining UIOP/UTILITY:UIOP-DEBUG in DEFMACRO
WARNING: redefining UIOP/UTILITY:LOAD-UIOP-DEBUG-UTILITY in DEFUN
WARNING: redefining UIOP/UTILITY:NEST in DEFMACRO
WARNING: redefining UIOP/UTILITY:IF-LET in DEFMACRO
WARNING: redefining UIOP/UTILITY:PARSE-BODY in DEFUN
WARNING: redefining UIOP/UTILITY:WHILE-COLLECTING in DEFMACRO
WARNING: redefining UIOP/UTILITY:APPENDF in DEFMACRO
WARNING: redefining UIOP/UTILITY:LENGTH=N-P in DEFUN
WARNING: redefining UIOP/UTILITY:ENSURE-LIST in DEFUN
WARNING: redefining UIOP/UTILITY:REMOVE-PLIST-KEY in DEFUN
WARNING: redefining UIOP/UTILITY:REMOVE-PLIST-KEYS in DEFUN
WARNING: redefining UIOP/UTILITY:EMPTYP in DEFUN
WARNING: redefining UIOP/UTILITY:CHARACTER-TYPE-INDEX in DEFUN
WARNING: redefining UIOP/UTILITY:BASE-STRING-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRINGS-COMMON-ELEMENT-TYPE in DEFUN
WARNING: redefining UIOP/UTILITY:REDUCE/STRCAT in DEFUN
WARNING: redefining UIOP/UTILITY:STRCAT in DEFUN
WARNING: redefining UIOP/UTILITY:FIRST-CHAR in DEFUN
WARNING: redefining UIOP/UTILITY:LAST-CHAR in DEFUN
WARNING: redefining UIOP/UTILITY:SPLIT-STRING in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-PREFIX-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-SUFFIX-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRING-ENCLOSED-P in DEFUN
WARNING: redefining UIOP/UTILITY:STRIPLN in DEFUN
WARNING: redefining UIOP/UTILITY:STANDARD-CASE-SYMBOL-NAME in DEFUN
WARNING: redefining UIOP/UTILITY:FIND-STANDARD-CASE-SYMBOL in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP*< in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMP<= in DEFUN
WARNING: redefining UIOP/UTILITY:EARLIER-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS-EARLIEST in DEFUN
WARNING: redefining UIOP/UTILITY:EARLIEST-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:LATER-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:TIMESTAMPS-LATEST in DEFUN
WARNING: redefining UIOP/UTILITY:LATEST-TIMESTAMP in DEFUN
WARNING: redefining UIOP/UTILITY:LATEST-TIMESTAMP-F in DEFMACRO
WARNING: redefining UIOP/UTILITY:ENSURE-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:ACCESS-AT in DEFUN
WARNING: redefining UIOP/UTILITY:ACCESS-AT-COUNT in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-FUNCTIONS in DEFUN
WARNING: redefining UIOP/UTILITY:REGISTER-HOOK-FUNCTION in DEFUN
WARNING: redefining UIOP/UTILITY:COERCE-CLASS in DEFUN
WARNING: redefining UIOP/UTILITY:ENSURE-GETHASH in DEFUN
WARNING: redefining UIOP/UTILITY:LIST-TO-HASH-SET in DEFUN
WARNING: redefining UIOP/UTILITY:LEXICOGRAPHIC< in DEFUN
WARNING: redefining UIOP/UTILITY:LEXICOGRAPHIC<= in DEFUN
WARNING: redefining UIOP/UTILITY:STYLE-WARN in DEFUN
WARNING: redefining UIOP/UTILITY:MATCH-CONDITION-P in DEFUN
WARNING: redefining UIOP/UTILITY:MATCH-ANY-CONDITION-P in DEFUN
WARNING: redefining UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS in DEFUN
WARNING: redefining UIOP/UTILITY:WITH-MUFFLED-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/UTILITY:NOT-IMPLEMENTED-ERROR in DEFUN
WARNING: redefining UIOP/UTILITY:PARAMETER-ERROR in DEFUN
WARNING: redefining UIOP/UTILITY:BOOLEAN-TO-FEATURE-EXPRESSION in DEFUN
WARNING: redefining UIOP/UTILITY:SYMBOL-TEST-TO-FEATURE-EXPRESSION in DEFUN
WARNING: redefining UIOP/VERSION:UNPARSE-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:PARSE-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:NEXT-VERSION in DEFUN
WARNING: redefining UIOP/VERSION:VERSION< in DEFUN
WARNING: redefining UIOP/VERSION:VERSION<= in DEFUN
WARNING: redefining UIOP/VERSION::DEPRECATED-FUNCTION-CONDITION-KIND in DEFUN
WARNING: redefining PRINT-OBJECT (#<SB-PCL::CONDITION-CLASS UIOP/VERSION:DEPRECATED-FUNCTION-CONDITION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/VERSION::NOTIFY-DEPRECATED-FUNCTION in DEFUN
WARNING: redefining UIOP/VERSION:VERSION-DEPRECATION in DEFUN
WARNING: redefining UIOP/VERSION:WITH-DEPRECATION in DEFMACRO
WARNING: redefining UIOP/OS:FEATUREP in DEFUN
WARNING: redefining UIOP/OS:OS-MACOSX-P in DEFUN
WARNING: redefining UIOP/OS:OS-UNIX-P in DEFUN
WARNING: redefining UIOP/OS:OS-WINDOWS-P in DEFUN
WARNING: redefining UIOP/OS:OS-GENERA-P in DEFUN
WARNING: redefining UIOP/OS::OS-OLDMAC-P in DEFUN
WARNING: redefining UIOP/OS::OS-HAIKU-P in DEFUN
WARNING: redefining UIOP/OS::OS-MEZZANO-P in DEFUN
WARNING: redefining UIOP/OS:DETECT-OS in DEFUN
WARNING: redefining UIOP/OS:OS-COND in DEFMACRO
WARNING: redefining UIOP/OS:GETENV in DEFUN
WARNING: redefining UIOP/OS:GETENVP in DEFUN
WARNING: redefining UIOP/OS::FIRST-FEATURE in DEFUN
WARNING: redefining UIOP/OS:IMPLEMENTATION-TYPE in DEFUN
WARNING: redefining UIOP/OS:OPERATING-SYSTEM in DEFUN
WARNING: redefining UIOP/OS:ARCHITECTURE in DEFUN
WARNING: redefining UIOP/OS:LISP-VERSION-STRING in DEFUN
WARNING: redefining UIOP/OS:IMPLEMENTATION-IDENTIFIER in DEFUN
WARNING: redefining UIOP/OS:HOSTNAME in DEFUN
WARNING: redefining UIOP/OS:GETCWD in DEFUN
WARNING: redefining UIOP/OS:CHDIR in DEFUN
WARNING: redefining UIOP/OS:READ-NULL-TERMINATED-STRING in DEFUN
WARNING: redefining UIOP/OS:READ-LITTLE-ENDIAN in DEFUN
WARNING: redefining UIOP/OS:PARSE-FILE-LOCATION-INFO in DEFUN
WARNING: redefining UIOP/OS:PARSE-WINDOWS-SHORTCUT in DEFUN
WARNING: redefining UIOP/PATHNAME:NORMALIZE-PATHNAME-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:DENORMALIZE-PATHNAME-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:MERGE-PATHNAME-DIRECTORY-COMPONENTS in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME* in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME-COMPONENT-LOGICAL in DEFUN
WARNING: redefining UIOP/PATHNAME:MAKE-PATHNAME-LOGICAL in DEFUN
WARNING: redefining UIOP/PATHNAME:MERGE-PATHNAMES* in DEFUN
WARNING: redefining UIOP/PATHNAME:LOGICAL-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PHYSICAL-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PHYSICALIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:NIL-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:WITH-PATHNAME-DEFAULTS in DEFMACRO
WARNING: redefining UIOP/PATHNAME:PATHNAME-EQUAL in DEFUN
WARNING: redefining UIOP/PATHNAME:ABSOLUTE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:HIDDEN-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:FILE-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-PARENT-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORY-PATHNAME-P in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-DIRECTORY-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SPLIT-UNIX-NAMESTRING-DIRECTORY-COMPONENTS in DEFUN
WARNING: redefining UIOP/PATHNAME:SPLIT-NAME-TYPE in DEFUN
WARNING: redefining UIOP/PATHNAME:PARSE-UNIX-NAMESTRING in DEFUN
WARNING: redefining UIOP/PATHNAME:UNIX-NAMESTRING in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHNAME* in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-ROOT in DEFUN
WARNING: redefining UIOP/PATHNAME:PATHNAME-HOST-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-ABSOLUTE-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:SUBPATHP in DEFUN
WARNING: redefining UIOP/PATHNAME:ENOUGH-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME in DEFUN
WARNING: redefining UIOP/PATHNAME:WITH-ENOUGH-PATHNAME in DEFMACRO
WARNING: redefining UIOP/PATHNAME:WILDEN in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVIZE-DIRECTORY-COMPONENT in DEFUN
WARNING: redefining UIOP/PATHNAME:RELATIVIZE-PATHNAME-DIRECTORY in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORY-SEPARATOR-FOR-HOST in DEFUN
WARNING: redefining UIOP/PATHNAME:DIRECTORIZE-PATHNAME-HOST-DEVICE in DEFUN
WARNING: redefining UIOP/PATHNAME:TRANSLATE-PATHNAME* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:NATIVE-NAMESTRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:PARSE-NATIVE-NAMESTRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:TRUENAME* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SAFE-FILE-WRITE-DATE in DEFUN
WARNING: redefining UIOP/FILESYSTEM:PROBE-FILE* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY-EXISTS-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:FILE-EXISTS-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY* in DEFUN
WARNING: redefining UIOP/FILESYSTEM:FILTER-LOGICAL-DIRECTORY-RESULTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DIRECTORY-FILES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SUBDIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:COLLECT-SUB*DIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:TRUENAMIZE in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RESOLVE-SYMLINKS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RESOLVE-SYMLINKS* in DEFUN
WARNING: redefining UIOP/PATHNAME:ENSURE-PATHNAME in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GET-PATHNAME-DEFAULTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:CALL-WITH-CURRENT-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:WITH-CURRENT-DIRECTORY in DEFMACRO
WARNING: redefining UIOP/FILESYSTEM:INTER-DIRECTORY-SEPARATOR in DEFUN
WARNING: redefining UIOP/FILESYSTEM:SPLIT-NATIVE-PATHNAMES-STRING in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-PATHNAME in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-PATHNAMES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-ABSOLUTE-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:GETENV-ABSOLUTE-DIRECTORIES in DEFUN
WARNING: redefining UIOP/FILESYSTEM:LISP-IMPLEMENTATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:LISP-IMPLEMENTATION-PATHNAME-P in DEFUN
WARNING: redefining UIOP/FILESYSTEM:ENSURE-ALL-DIRECTORIES-EXIST in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-FILE-IF-EXISTS in DEFUN
WARNING: redefining UIOP/FILESYSTEM:RENAME-FILE-OVERWRITING-TARGET in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-EMPTY-DIRECTORY in DEFUN
WARNING: redefining UIOP/FILESYSTEM:DELETE-DIRECTORY-TREE in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDIN in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDOUT in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-STDERR in DEFUN
WARNING: redefining UIOP/STREAM:ALWAYS-DEFAULT-ENCODING in DEFUN
WARNING: redefining UIOP/STREAM:DETECT-ENCODING in DEFUN
WARNING: redefining UIOP/STREAM:DEFAULT-ENCODING-EXTERNAL-FORMAT in DEFUN
WARNING: redefining UIOP/STREAM:ENCODING-EXTERNAL-FORMAT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-SAFE-IO-SYNTAX in DEFMACRO
WARNING: redefining UIOP/STREAM:CALL-WITH-SAFE-IO-SYNTAX in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FROM-STRING in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-OUTPUT-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-OUTPUT-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::CALL-WITH-OUTPUT in DEFUN
WARNING: redefining UIOP/STREAM:OUTPUT-STRING in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-INPUT-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-INPUT-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::CALL-WITH-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-INPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:INPUT-STRING in DEFUN
WARNING: redefining UIOP/STREAM:NULL-DEVICE-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-NULL-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-NULL-INPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:CALL-WITH-NULL-OUTPUT in DEFUN
WARNING: redefining UIOP/STREAM:WITH-NULL-OUTPUT in DEFMACRO
WARNING: redefining UIOP/STREAM:FINISH-OUTPUTS in DEFUN
WARNING: redefining UIOP/STREAM:FORMAT! in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-FORMAT! in DEFUN
WARNING: redefining UIOP/STREAM:COPY-STREAM-TO-STREAM in DEFUN
WARNING: redefining UIOP/STREAM:CONCATENATE-FILES in DEFUN
WARNING: redefining UIOP/STREAM:COPY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-STRING in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-LINES in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-LINE in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-FORMS in DEFUN
WARNING: redefining UIOP/STREAM:SLURP-STREAM-FORM in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-STRING in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-LINES in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-LINE in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-FORMS in DEFUN
WARNING: redefining UIOP/STREAM:READ-FILE-FORM in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FILE-LINE in DEFUN
WARNING: redefining UIOP/STREAM:SAFE-READ-FILE-FORM in DEFUN
WARNING: redefining UIOP/STREAM:EVAL-INPUT in DEFUN
WARNING: redefining UIOP/STREAM:EVAL-THUNK in DEFUN
WARNING: redefining UIOP/STREAM:STANDARD-EVAL-THUNK in DEFUN
WARNING: redefining UIOP/STREAM:PRINTLN in DEFUN
WARNING: redefining UIOP/STREAM:WRITELN in DEFUN
WARNING: redefining UIOP/STREAM:DEFAULT-TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:SETUP-TEMPORARY-DIRECTORY in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-TEMPORARY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:WITH-TEMPORARY-FILE in DEFMACRO
WARNING: redefining UIOP/STREAM::GET-TEMPORARY-FILE in DEFUN
WARNING: redefining UIOP/STREAM:ADD-PATHNAME-SUFFIX in DEFUN
WARNING: redefining UIOP/STREAM:TMPIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:CALL-WITH-STAGING-PATHNAME in DEFUN
WARNING: redefining UIOP/STREAM:WITH-STAGING-PATHNAME in DEFMACRO
WARNING: redefining UIOP/STREAM:FILE-STREAM-P in DEFUN
WARNING: redefining UIOP/STREAM:FILE-OR-SYNONYM-STREAM-P in DEFUN
WARNING: redefining UIOP/IMAGE:QUIT in DEFUN
WARNING: redefining UIOP/IMAGE:DIE in DEFUN
WARNING: redefining UIOP/IMAGE:RAW-PRINT-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:PRINT-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:PRINT-CONDITION-BACKTRACE in DEFUN
WARNING: redefining UIOP/IMAGE:FATAL-CONDITION-P in DEFUN
WARNING: redefining UIOP/IMAGE:HANDLE-FATAL-CONDITION in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-WITH-FATAL-CONDITION-HANDLER in DEFUN
WARNING: redefining UIOP/IMAGE:WITH-FATAL-CONDITION-HANDLER in DEFMACRO
WARNING: redefining UIOP/IMAGE:SHELL-BOOLEAN-EXIT in DEFUN
WARNING: redefining UIOP/IMAGE:REGISTER-IMAGE-RESTORE-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:REGISTER-IMAGE-DUMP-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-IMAGE-RESTORE-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:CALL-IMAGE-DUMP-HOOK in DEFUN
WARNING: redefining UIOP/IMAGE:RAW-COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:ARGV0 in DEFUN
WARNING: redefining UIOP/IMAGE:SETUP-COMMAND-LINE-ARGUMENTS in DEFUN
WARNING: redefining UIOP/IMAGE:RESTORE-IMAGE in DEFUN
WARNING: redefining UIOP/IMAGE:DUMP-IMAGE in DEFUN
WARNING: redefining UIOP/IMAGE:CREATE-IMAGE in DEFUN
WARNING: redefining UIOP/LISP-BUILD::SB-GROVEL-UNKNOWN-CONSTANT-CONDITION-P in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CALL-WITH-MUFFLED-COMPILER-CONDITIONS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-MUFFLED-COMPILER-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CALL-WITH-MUFFLED-LOADER-CONDITIONS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-MUFFLED-LOADER-CONDITIONS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CHECK-LISP-COMPILE-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:REIFY-SIMPLE-SEXP in DEFUN
WARNING: redefining UIOP/LISP-BUILD:UNREIFY-SIMPLE-SEXP in DEFUN
WARNING: redefining UIOP/LISP-BUILD::REIFY-UNDEFINED-WARNING in DEFUN
WARNING: redefining UIOP/LISP-BUILD:REIFY-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:UNREIFY-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:RESET-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:SAVE-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WARNINGS-FILE-TYPE in DEFUN
WARNING: redefining UIOP/LISP-BUILD:ENABLE-DEFERRED-WARNINGS-CHECK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:DISABLE-DEFERRED-WARNINGS-CHECK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WARNINGS-FILE-P in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CHECK-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD::CALL-WITH-SAVED-DEFERRED-WARNINGS in DEFUN
WARNING: redefining UIOP/LISP-BUILD:WITH-SAVED-DEFERRED-WARNINGS in DEFMACRO
WARNING: redefining UIOP/LISP-BUILD:CURRENT-LISP-FILE-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LISPIZE-PATHNAME in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE-TYPE in DEFUN
WARNING: redefining UIOP/LISP-BUILD:CALL-AROUND-HOOK in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE-PATHNAME* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMPILE-FILE* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD* in DEFUN
WARNING: redefining UIOP/LISP-BUILD:LOAD-FROM-STRING in DEFUN
WARNING: redefining UIOP/LISP-BUILD:COMBINE-FASLS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::REQUIRES-ESCAPING-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::ESCAPE-WINDOWS-TOKEN-WITHIN-DOUBLE-QUOTES in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::EASY-WINDOWS-CHARACTER-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-WINDOWS-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::ESCAPE-SH-TOKEN-WITHIN-DOUBLE-QUOTES in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:EASY-SH-CHARACTER-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SH-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SHELL-TOKEN in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-WINDOWS-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SH-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:ESCAPE-SHELL-COMMAND in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%NORMALIZE-IO-SPECIFIER in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%INTERACTIVEP in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%SIGNAL-TO-EXIT-CODE in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%CODE-TO-STATUS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%HANDLE-IF-EXISTS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%HANDLE-IF-DOES-NOT-EXIST in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-ERROR-OUTPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-INPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-OUTPUT in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-INFO-PID in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%PROCESS-STATUS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:PROCESS-ALIVE-P in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:WAIT-PROCESS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM::%POSIX-SEND-SIGNAL in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:TERMINATE-PROCESS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:CLOSE-STREAMS in DEFUN
WARNING: redefining UIOP/LAUNCH-PROGRAM:LAUNCH-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::CALL-STREAM-PROCESSOR in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM:SLURP-INPUT-STREAM in DEFGENERIC
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:FUNCTION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:CONS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:STREAM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :LINES> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :LINE> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :FORMS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER :FORM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:NULL> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:PATHNAME> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining SLURP-INPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/RUN-PROGRAM:VOMIT-OUTPUT-STREAM in DEFGENERIC
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:FUNCTION> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:CONS> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:STREAM> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:STRING> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-MOP:EQL-SPECIALIZER T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:NULL> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<BUILT-IN-CLASS COMMON-LISP:PATHNAME> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining VOMIT-OUTPUT-STREAM (#<SB-PCL:SYSTEM-CLASS COMMON-LISP:T> #<SB-PCL:SYSTEM-CLASS COMMON-LISP:T>) in DEFMETHOD
WARNING: redefining UIOP/RUN-PROGRAM::%CHECK-RESULT in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%ACTIVE-IO-SPECIFIER-P in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%RUN-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%CALL-WITH-PROGRAM-IO in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::PLACE-SETTER in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-INPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-OUTPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::WITH-PROGRAM-ERROR-OUTPUT in DEFMACRO
WARNING: redefining UIOP/RUN-PROGRAM::%USE-LAUNCH-PROGRAM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%NORMALIZE-SYSTEM-COMMAND in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%REDIRECTED-SYSTEM-COMMAND in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%SYSTEM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM::%USE-SYSTEM in DEFUN
WARNING: redefining UIOP/RUN-PROGRAM:RUN-PROGRAM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:CONFIGURATION-INHERITANCE-DIRECTIVE-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:REPORT-INVALID-FORM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FORM in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-FILE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:VALIDATE-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-RELATIVE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-ABSOLUTE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:RESOLVE-LOCATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:LOCATION-DESIGNATOR-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:LOCATION-FUNCTION-P in DEFUN
WARNING: redefining UIOP/CONFIGURATION:REGISTER-CLEAR-CONFIGURATION-HOOK in DEFUN
WARNING: redefining UIOP/CONFIGURATION:CLEAR-CONFIGURATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:UPGRADE-CONFIGURATION in DEFUN
WARNING: redefining UIOP/CONFIGURATION:GET-FOLDER-PATH in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-DIRS in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-DIRS in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CACHE-HOME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-RUNTIME-DIR in DEFUN
WARNING: redefining UIOP/CONFIGURATION:SYSTEM-CONFIG-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:FILTER-PATHNAME-SET in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-PATHNAMES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:FIND-PREFERRED-FILE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-DATA-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:XDG-CONFIG-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION::COMPUTE-USER-CACHE in DEFUN
WARNING: redefining UIOP/CONFIGURATION:UIOP-DIRECTORY in DEFUN
WARNING: redefining UIOP/BACKWARD-DRIVER:COERCE-PATHNAME in DEFUN
WARNING: redefining UIOP/CONFIGURATION:USER-CONFIGURATION-DIRECTORIES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:SYSTEM-CONFIGURATION-DIRECTORIES in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-FIRST-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-USER-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/CONFIGURATION:IN-SYSTEM-CONFIGURATION-DIRECTORY in DEFUN
WARNING: redefining UIOP/BACKWARD-DRIVER:VERSION-COMPATIBLE-P in DEFUN

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/7ab3a2a95b8fc056011b2f5e9e699b2a0f556c8e/cl+ssl-20250708-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.

; 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)
; --> 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>"

; 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)
; --> 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>"

; in: DEFUN ENCODE-OPENSSL-VERSION-IMPL
;     (POSITION CL+SSL::PATCH CL+SSL::+OPENSSL-VERSION-PATCH-CHARACTERS+)
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR LIST VECTOR).

;     (POSITION CL+SSL::STATUS CL+SSL::+OPENSSL-VERSION-STATUS-STRINGS+ :TEST
;               #'STRING=)
; 
; note: unable to optimize due to type uncertainty: The second argument is a SEQUENCE, not a (OR LIST VECTOR).

;     (LOGIOR (ASH CL+SSL::MAJOR 28) (ASH CL+SSL::MINOR 20) (ASH CL+SSL::FIX 12)
;             (ASH CL+SSL::PATCH-INT 4) CL+SSL::STATUS-INT)
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a (OR NULL INTEGER), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The second argument is a (OR NULL INTEGER), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN ENCODE-OPENSSL-VERSION
;     (>= CL+SSL::MAJOR 3)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first 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 DOUBLE-FLOAT.

; 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-OR-FIX))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), 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 (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.

; 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-OR-FIX))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (NOT NULL), 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 (NOT NULL), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       etc.

; 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 SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; 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))
; --> 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 #:G1 :POINTER)
;                               :CONVENTION :CDECL :LIBRARY
;                               CL+SSL/CONFIG::LIBSSL)
;    #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
; 
; note: doing SAP to pointer coercion (cost 20)

; 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)
; --> 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>"

;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv23_server_method" CL+SSL::SSL-V23-SERVER-METHOD)
;       CL+SSL::SSL-METHOD)
; --> 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>"

;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv23_method" CL+SSL::SSL-V23-METHOD)
;       CL+SSL::SSL-METHOD)
; --> 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>"

;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv3_client_method" CL+SSL::SSL-V3-CLIENT-METHOD)
;       CL+SSL::SSL-METHOD)
; --> 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>"

;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv3_server_method" CL+SSL::SSL-V3-SERVER-METHOD)
;       CL+SSL::SSL-METHOD)
; --> 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>"

;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "1.1.0")
;       ("SSLv3_method" CL+SSL::SSL-V3-METHOD)
;       CL+SSL::SSL-METHOD)
; --> 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>"

; 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)
; --> 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>"

; 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)
; --> 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>"

; 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)
; --> 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>"

; 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)
; --> 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>"

;     (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)
; --> 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>"

;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_1_method" CL+SSL::SSL-TLSV1-1-METHOD)
;       CL+SSL::SSL-METHOD)
; --> 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>"

;     (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)
; --> 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>"

;     (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)
; --> 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>"

;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "1.0.2")
;       ("TLSv1_2_method" CL+SSL::SSL-TLSV1-2-METHOD)
;       CL+SSL::SSL-METHOD)
; --> 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>"

; 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)
; --> 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>"

; 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))
; --> 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 ((#:G1 METHOD))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_CTX_new" (:POINTER #:G1 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::CTX))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_new" (:POINTER #:G1 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::BIO))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 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>"

; in: DEFINE-CRYPTO-FUNCTION ("BIO_new" BIO-NEW)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("BIO_new" CL+SSL::BIO-NEW)
;       :POINTER
;       (METHOD :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::BIO-NEW
;         (METHOD)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::BIO-NEW
;         (LET ((#:G1 METHOD))
;           (CFFI-SYS:%FOREIGN-FUNCALL "BIO_new" (:POINTER #:G1 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; in: DEFINE-CRYPTO-FUNCTION ("BIO_free" BIO-FREE)
;     (CL+SSL::DEFINE-CRYPTO-FUNCTION
;       ("BIO_free" CL+SSL::BIO-FREE)
;       :POINTER
;       (METHOD :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::BIO-FREE
;         (METHOD)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::BIO-FREE
;         (LET ((#:G1 METHOD))
;           (CFFI-SYS:%FOREIGN-FUNCALL "BIO_free" (:POINTER #:G1 :POINTER)
;                                      :CONVENTION :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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>"

; 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)
; --> 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>"

; 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))
; --> 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 #:G1 :POINTER #:G2 :POINTER)
;                               :CONVENTION :CDECL :LIBRARY
;                               CL+SSL/CONFIG::LIBCRYPTO)
;    #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
; 
; note: doing SAP to pointer coercion (cost 20)

; 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))
; --> 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 ((#:G1 CL+SSL::CTX))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::SSL))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; 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)

; 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)

; 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)

; 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))
; --> 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 (#:G1 #:PARAM2)
;             (CFFI:TRANSLATE-TO-FOREIGN CL+SSL::FILE
;                                        #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
;           (UNWIND-PROTECT (PROGN #)
;             (CFFI:FREE-TRANSLATED-OBJECT #:G1 # #:PARAM2)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::SSL))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_get_verify_result"
;                                      (:POINTER #:G1 :LONG) :CONVENTION :CDECL
;                                      :LIBRARY CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing signed word to integer coercion (cost 20) to "<return value>"

; in: DEFINE-SSL-FUNCTION-EX (:VANISHED "3.0.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:VANISHED "3.0.0")
;       ("SSL_get_peer_certificate" CL+SSL::SSL-GET-PEER-CERTIFICATE)
;       :POINTER
;       (CL+SSL::SSL CL+SSL::SSL-POINTER))
; --> 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>"

; in: DEFINE-SSL-FUNCTION-EX (:SINCE "3.0.0")
;     (CL+SSL::DEFINE-SSL-FUNCTION-EX
;       (:SINCE "3.0.0")
;       ("SSL_get1_peer_certificate" CL+SSL::SSL-GET1-PEER-CERTIFICATE)
;       :POINTER
;       (CL+SSL::SSL CL+SSL::SSL-POINTER))
; --> 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-GET1-PEER-CERTIFICATE
;         (CL+SSL::SSL)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK CL+SSL::SSL-GET1-PEER-CERTIFICATE
;         (LET ((#:G0 CL+SSL::SSL))
;           (CFFI-SYS:%FOREIGN-FUNCALL "SSL_get1_peer_certificate"
;                                      (:POINTER #:G0 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY CL+SSL/CONFIG::LIBSSL))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::X509-NAME))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 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>"

; 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))
; --> 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 ((#:G1 CL+SSL::NAME-ENTRY))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_NAME_ENTRY_get_data"
;                                      (:POINTER #:G1 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::X509))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_get_issuer_name"
;                                      (:POINTER #:G1 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::X509))
;           (CFFI-SYS:%FOREIGN-FUNCALL "X509_get_subject_name"
;                                      (:POINTER #:G1 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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>"

;     (CL+SSL::DEFINE-CRYPTO-FUNCTION-EX
;       (:SINCE "1.1.0")
;       ("X509_get0_notAfter" CL+SSL::X509-GET0-NOT-AFTER)
;       :POINTER
;       (CL+SSL::X509 :POINTER))
; --> 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>"

; 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))
; --> 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 ((#:G1 CL+SSL::CERT))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::*PX))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::BIO))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 (#:G1 #:PARAM2)
;             (CFFI:TRANSLATE-TO-FOREIGN CL+SSL::NAME
;                                        #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
;           (UNWIND-PROTECT (PROGN #)
;             (CFFI:FREE-TRANSLATED-OBJECT #:G1 # #:PARAM2)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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>"

; 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))
; --> 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>"

; 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)))
; --> 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 efficiently:
; (VALUES SB-SYS:SYSTEM-AREA-POINTER &REST T).
; It allows an unknown number of values, consider using
; (VALUES SB-SYS:SYSTEM-AREA-POINTER &OPTIONAL).

; 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)))
; --> 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 efficiently:
; (VALUES FIXNUM &REST T).
; It allows an unknown number of values, consider using
; (VALUES FIXNUM &OPTIONAL).

; 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))
; --> 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 ((#:G1 CL+SSL::ASN1-STRING))
;           (CFFI-SYS:%FOREIGN-FUNCALL "ASN1_STRING_data"
;                                      (:POINTER #:G1 :POINTER) :CONVENTION
;                                      :CDECL :LIBRARY
;                                      CL+SSL/CONFIG::LIBCRYPTO))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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 ((#:G1 CL+SSL::NUM))
;           (LET (#)
;             (LET #
;               #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; 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))
; --> 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>"

; 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/7ab3a2a95b8fc056011b2f5e9e699b2a0f556c8e/cl+ssl-20250708-git/src/bio.lisp
; in: CFFI:DEFCALLBACK LISP-WRITE
;     (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
; 
; note: doing SAP to pointer coercion (cost 20)

; in: CFFI:DEFCALLBACK LISP-READ
;     (CFFI:DEFCALLBACK CL+SSL::LISP-READ
;         :INT
;         ((CL+SSL::BIO :POINTER) (CL+SSL::BUF :POINTER) (CL+SSL::N :INT))
;       (HANDLER-CASE
;        (LET ((CL+SSL::I 0))
;          (HANDLER-CASE (PROGN # # #) (END-OF-FILE NIL #))
;          (IF (= 0 CL+SSL::I)
;              -1
;              CL+SSL::I))
;        (SERIOUS-CONDITION (CL+SSL::C) (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) -1)))
; --> CFFI-SYS:%DEFCALLBACK PROGN DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::%DEFINE-ALIEN-CALLABLE SB-ALIEN::%DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::ALIEN-LAMBDA2 LAMBDA FUNCTION LET LET SETF LET* THE LOCALLY 
; ==>
;   (LET ((CL+SSL::BIO CL+SSL::BIO)
;         (CL+SSL::BUF CL+SSL::BUF)
;         (CL+SSL::N CL+SSL::N))
;     (BLOCK CL+SSL::LISP-READ
;       (HANDLER-CASE
;        (LET (#)
;          (HANDLER-CASE # #)
;          (IF #
;              -1
;              CL+SSL::I))
;        (SERIOUS-CONDITION (CL+SSL::C) (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) -1))))
; 
; note: doing SAP to pointer coercion (cost 20) to BIO

; in: CFFI:DEFCALLBACK LISP-GETS
;     (CFFI:DEFCALLBACK CL+SSL::LISP-GETS
;         :INT
;         ((CL+SSL::BIO :POINTER) (CL+SSL::BUF :POINTER) (CL+SSL::N :INT))
;       (HANDLER-CASE
;        (LET ((CL+SSL::I 0) (CL+SSL::MAX-CHARS #))
;          (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;          (HANDLER-CASE
;           (LOOP CL+SSL::WITH CHAR
;                 AND CL+SSL::EXIT = NIL
;                 CL+SSL::WHILE #
;                 DO # # ...)
;           (END-OF-FILE NIL #))
;          (SETF # 0)
;          CL+SSL::I)
;        (SERIOUS-CONDITION (CL+SSL::C) (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) -1)))
; --> CFFI-SYS:%DEFCALLBACK PROGN DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::%DEFINE-ALIEN-CALLABLE SB-ALIEN::%DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::ALIEN-LAMBDA2 LAMBDA FUNCTION LET LET SETF LET* THE LOCALLY 
; ==>
;   (LET ((CL+SSL::BIO CL+SSL::BIO)
;         (CL+SSL::BUF CL+SSL::BUF)
;         (CL+SSL::N CL+SSL::N))
;     (BLOCK CL+SSL::LISP-GETS
;       (HANDLER-CASE
;        (LET (# #)
;          (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;          (HANDLER-CASE # #)
;          (SETF #)
;          CL+SSL::I)
;        (SERIOUS-CONDITION (CL+SSL::C) (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) -1))))
; 
; note: doing SAP to pointer coercion (cost 20) to BIO

; in: CFFI:DEFCALLBACK LISP-PUTS
;     (CFFI:DEFCALLBACK CL+SSL::LISP-PUTS
;         :INT
;         ((CL+SSL::BIO :POINTER) (CL+SSL::BUF :STRING))
;       (HANDLER-CASE
;        (PROGN
;         (WRITE-LINE CL+SSL::BUF
;                     (FLEXI-STREAMS:MAKE-FLEXI-STREAM CL+SSL::*BIO-SOCKET*
;                                                      :EXTERNAL-FORMAT :ASCII))
;         (1+ (LENGTH CL+SSL::BUF)))
;        (SERIOUS-CONDITION (CL+SSL::C) (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) -1)))
; --> CFFI-SYS:%DEFCALLBACK PROGN DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::%DEFINE-ALIEN-CALLABLE SB-ALIEN::%DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::ALIEN-LAMBDA2 LAMBDA FUNCTION LET LET SETF LET* THE LOCALLY LET 
; ==>
;   (CFFI:TRANSLATE-FROM-FOREIGN CL+SSL::BUF #<CFFI::FOREIGN-STRING-TYPE :UTF-8>)
; 
; note: doing SAP to pointer coercion (cost 20)

;     (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
; 
; note: doing SAP to pointer coercion (cost 20)

; in: CFFI:DEFCALLBACK LISP-CTRL
;     (ZEROP (CL+SSL::COMPAT-BIO-TEST-FLAGS CL+SSL::BIO CL+SSL::+BIO_FLAGS_IN_EOF+))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (CL+SSL::COMPAT-BIO-TEST-FLAGS CL+SSL::BIO CL+SSL::+BIO_FLAGS_IN_EOF+)
; 
; note: doing SAP to pointer coercion (cost 20)

; in: CFFI:DEFCALLBACK LISP-CREATE-OPAQUE
;     (CFFI:DEFCALLBACK CL+SSL::LISP-CREATE-OPAQUE
;         :INT
;         ((CL+SSL::BIO :POINTER))
;       (HANDLER-CASE
;        (PROGN
;         (CL+SSL::BIO-SET-INIT CL+SSL::BIO 1)
;         (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;         1)
;        (SERIOUS-CONDITION (CL+SSL::C)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) 0)))
; --> CFFI-SYS:%DEFCALLBACK PROGN DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::%DEFINE-ALIEN-CALLABLE SB-ALIEN::%DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::ALIEN-LAMBDA2 LAMBDA FUNCTION LET LET SETF LET* THE LOCALLY 
; ==>
;   (LET ((CL+SSL::BIO CL+SSL::BIO))
;     (BLOCK CL+SSL::LISP-CREATE-OPAQUE
;       (HANDLER-CASE
;        (PROGN
;         (CL+SSL::BIO-SET-INIT CL+SSL::BIO 1)
;         (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO)
;         1)
;        (SERIOUS-CONDITION (CL+SSL::C)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) 0))))
; 
; note: doing SAP to pointer coercion (cost 20) to BIO

; in: CFFI:DEFCALLBACK LISP-DESTROY-OPAQUE
;     (CFFI:DEFCALLBACK CL+SSL::LISP-DESTROY-OPAQUE
;         :INT
;         ((CL+SSL::BIO :POINTER))
;       (HANDLER-CASE
;        (COND ((CFFI-SYS:NULL-POINTER-P CL+SSL::BIO) 0)
;              (T (CL+SSL::BIO-SET-INIT CL+SSL::BIO 0)
;               (CL+SSL::CLEAR-RETRY-FLAGS CL+SSL::BIO) 1))
;        (SERIOUS-CONDITION (CL+SSL::C)
;         (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) 0)))
; --> CFFI-SYS:%DEFCALLBACK PROGN DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::%DEFINE-ALIEN-CALLABLE SB-ALIEN::%DEFINE-ALIEN-CALLABLE 
; --> SB-ALIEN::ALIEN-LAMBDA2 LAMBDA FUNCTION LET LET SETF LET* THE LOCALLY 
; ==>
;   (LET ((CL+SSL::BIO CL+SSL::BIO))
;     (BLOCK CL+SSL::LISP-DESTROY-OPAQUE
;       (HANDLER-CASE (COND (# 0) (T # # 1))
;                     (SERIOUS-CONDITION (CL+SSL::C)
;                      (CL+SSL::PUT-TO-OPENSSL-ERROR-QUEUE CL+SSL::C) 0))))
; 
; note: doing SAP to pointer coercion (cost 20) to BIO

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/7ab3a2a95b8fc056011b2f5e9e699b2a0f556c8e/cl+ssl-20250708-git/src/ssl-funcall.lisp
; in: DEFUN SECONDS-UNTIL-DEADLINE
;     (/ (- CL+SSL::DEADLINE (GET-INTERNAL-REAL-TIME))
;        INTERNAL-TIME-UNITS-PER-SECOND)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN ENSURE-SSL-FUNCALL
;     (APPLY CL+SSL::FUNC CL+SSL::HANDLE CL+SSL::OTHER-ARGS)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNC is not known to be a function

;     (FUNCALL CL+SSL::SUCCESS-TEST CL+SSL::RET)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: SUCCESS-TEST is not known to be a function

; in: DEFUN NONBLOCKING-SSL-FUNCALL
;     (APPLY CL+SSL::FUNC CL+SSL::HANDLE CL+SSL::OTHER-ARGS)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUNC is not known to be a function

;     (FUNCALL CL+SSL::SUCCESS-TEST CL+SSL::RET)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: SUCCESS-TEST is not known to be a function

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/7ab3a2a95b8fc056011b2f5e9e699b2a0f556c8e/cl+ssl-20250708-git/src/init.lisp
; in: CFFI:DEFCALLBACK TMP-RSA-CALLBACK
;     (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)

; 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 (OR NULL (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 LIST.
; 
; 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 (OR NULL (SIMPLE-ARRAY CHARACTER (*))).

; 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)

; 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.

; in: CFFI:DEFCALLBACK THREADID-CALLBACK
;     (INCF CL+SSL::*THREAD-COUNTER*)
; --> THE 
; ==>
;   (+ 1 CL+SSL::*THREAD-COUNTER*)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFUN INITIALIZE
;     (LOOP CL+SSL::REPEAT (CL+SSL::CRYPTO-NUM-LOCKS)
;           CL+SSL::COLLECT (BORDEAUX-THREADS:MAKE-LOCK))
; --> LET CEILING 
; ==>
;   1
; 
; 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 optimize due to type uncertainty: The first argument is a REAL, not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The first argument is a REAL, not a (UNSIGNED-BYTE 62).
; 
; 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 fold division by 1 due to type uncertainty: The first argument is a REAL, not a INTEGER.

;     (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

;     (LOOP CL+SSL::REPEAT (CL+SSL::CRYPTO-NUM-LOCKS)
;           CL+SSL::COLLECT (BORDEAUX-THREADS:MAKE-LOCK))
; --> LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY IF <= 
; ==>
;   1
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

; --> LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY IF DECF SETQ THE 
; --> SB-IMPL::XSUBTRACT BLOCK 
; ==>
;   (- SB-IMPL::B SB-IMPL::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES UNSIGNED-BYTE &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl+ssl/7ab3a2a95b8fc056011b2f5e9e699b2a0f556c8e/cl+ssl-20250708-git/src/streams.lisp
; in: DEFMETHOD INITIALIZE-INSTANCE :AFTER (SSL-STREAM)
;     (CL+SSL::MAKE-BUFFER CL+SSL::OUTPUT-BUFFER-SIZE)
; --> BLOCK CFFI-SYS:MAKE-SHAREABLE-BYTE-VECTOR BLOCK MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER.

;     (CL+SSL::MAKE-BUFFER CL+SSL::INPUT-BUFFER-SIZE)
; --> BLOCK CFFI-SYS:MAKE-SHAREABLE-BYTE-VECTOR BLOCK MAKE-ARRAY 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR LIST (UNSIGNED-BYTE 44)), not a INTEGER.

; 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.

; in: DEFMETHOD CLOSE (SSL-STREAM)
;     (COMPLEMENT #'MINUSP)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first 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 DOUBLE-FLOAT.

;     (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

;     (COMPLEMENT #'MINUSP)
; 
; 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.

; in: DEFMETHOD STREAM-LISTEN (SSL-STREAM)
;     (> CL+SSL::N 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first 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 DOUBLE-FLOAT.

;     (CL+SSL::BUFFER-ELT CL+SSL::BUF 0)
; --> BLOCK ELT 
; ==>
;   1
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (CL+SSL::NONBLOCKING-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-READ
;                                      CL+SSL::HANDLE CL+SSL::PTR 1)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET WHEN IF FUNCALL 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first 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 DOUBLE-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.

;     (> CL+SSL::N 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a REAL, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.
;       etc.

;     (CL+SSL::NONBLOCKING-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-READ
;                                      CL+SSL::HANDLE CL+SSL::PTR 1)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET LET APPLY 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20)

; in: DEFMETHOD STREAM-READ-BYTE (SSL-STREAM)
;     (CL+SSL::BUFFER-ELT CL+SSL::BUF 0)
; --> BLOCK ELT 
; ==>
;   1
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.

;     (CL+SSL::ENSURE-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-READ CL+SSL::HANDLE
;                                 CL+SSL::PTR 1)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET WHEN IF FUNCALL 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first 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 DOUBLE-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.

; --> BLOCK LOOP BLOCK TAGBODY PROGN LET LET APPLY 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20)

; in: DEFMETHOD STREAM-READ-SEQUENCE (SSL-STREAM T T T)
;     (PLUSP LENGTH)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL * 17592186044415) (SINGLE-FLOAT * 1.7592186e13) (DOUBLE-FLOAT * 1.7592186044415d13)), not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (RATIONAL * 17592186044415) (SINGLE-FLOAT * 1.7592186e13) (DOUBLE-FLOAT * 1.7592186044415d13)), not a DOUBLE-FLOAT.

;     (< CL+SSL::START CL+SSL::END)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-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))
; 
; 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::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 (OR NULL (SIMPLE-ARRAY * (*))).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).The second argument is a (OR 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 (OR NULL (SIMPLE-ARRAY CHARACTER (*))).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY CHARACTER (*))).The second argument is a (OR 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 (OR SIMPLE-BASE-STRING NULL).

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

;     (CL+SSL::ENSURE-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-READ CL+SSL::HANDLE
;                                 CL+SSL::PTR LENGTH)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET WHEN IF FUNCALL 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first 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 DOUBLE-FLOAT.

;     (< 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 fixnum arithmetic (cost 2) because:
;       The first argument is a REAL, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       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 second 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 (OR (RATIONAL * 17592186044415) (SINGLE-FLOAT * 1.7592186e13) (DOUBLE-FLOAT * 1.7592186044415d13)), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR (RATIONAL * 17592186044415) (SINGLE-FLOAT * 1.7592186e13) (DOUBLE-FLOAT * 1.7592186044415d13)), not a FIXNUM.
;       etc.

;     (CL+SSL::ENSURE-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-READ CL+SSL::HANDLE
;                                 CL+SSL::PTR LENGTH)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET WHEN IF FUNCALL 
; ==>
;   1
; 
; 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.

;     (+ 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 REAL, not a FIXNUM.
;       The second argument is a (REAL (0)), not a FIXNUM.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES REAL &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (INCF CL+SSL::START CL+SSL::READ-BYTES)
; --> THE 
; ==>
;   (+ CL+SSL::READ-BYTES CL+SSL::START)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (RATIONAL (0)), not a FIXNUM.
;       The result is a (VALUES (RATIONAL (0)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (RATIONAL (0)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (RATIONAL (0)) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (CL+SSL::ENSURE-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-READ CL+SSL::HANDLE
;                                 CL+SSL::PTR LENGTH)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET LET APPLY 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20)

; in: DEFMETHOD STREAM-WRITE-BYTE (SSL-STREAM T)
;     (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)
; --> 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))
; ==>
;   (+ 1 (CL+SSL::SSL-STREAM-OUTPUT-POINTER #:STREAM7))
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; in: DEFMETHOD STREAM-WRITE-SEQUENCE (SSL-STREAM T T T)
;     (>
;      (+ (- 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 SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (> (- 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 SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (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 (OR NULL (SIMPLE-ARRAY * (*))).The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY CHARACTER (*))).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY CHARACTER (*))).The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).

;     (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 (OR NULL (SIMPLE-ARRAY * (*))).The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY * (*))).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).The second argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY CHARACTER (*))).
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a (OR NULL (SIMPLE-ARRAY CHARACTER (*))).The second argument is a SEQUENCE, not a (OR SIMPLE-BASE-STRING NULL).

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

; --> 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.
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (- CL+SSL::END CL+SSL::START)
; 
; 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 second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       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 fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       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 fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       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 &OPTIONAL).
;       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))
; ==>
;   (+ (- CL+SSL::END CL+SSL::START)
;      (CL+SSL::SSL-STREAM-OUTPUT-POINTER #:STREAM45))
; 
; 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 &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER -17592186044415 17592186044415), not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; 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 SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (CL+SSL::ENSURE-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-WRITE CL+SSL::HANDLE
;                                 CL+SSL::PTR CL+SSL::FILL-PTR)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET WHEN IF FUNCALL 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first 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 DOUBLE-FLOAT.

;     (PLUSP CL+SSL::FILL-PTR)
; 
; 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.

;     (CL+SSL::ENSURE-SSL-FUNCALL STREAM #'PLUSP #'CL+SSL::SSL-WRITE CL+SSL::HANDLE
;                                 CL+SSL::PTR CL+SSL::FILL-PTR)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET WHEN IF FUNCALL 
; ==>
;   1
; 
; 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.

; --> BLOCK LOOP BLOCK TAGBODY PROGN LET LET APPLY 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20)

; 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)))))
; --> SYMBOL-MACROLET SYMBOL-MACROLET LET LET 
; --> SB-ALIEN-INTERNALS:MAKE-LOCAL-ALIEN 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the first result of ALLOC-ALIEN-STACK-SPACE

; 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)

; 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 SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

;     (1- CL+SSL::LEN)
; 
; 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 &OPTIONAL).
;       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 &OPTIONAL).
;       etc.

; 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 SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
; 
; note: unable to open code because: The operands might not be the same type.

; in: DEFUN GET-SELECTED-ALPN-PROTOCOL
;     (CL+SSL::SSL-GET0-ALPN-SELECTED
;      (CL+SSL::SSL-STREAM-HANDLE CL+SSL::SSL-STREAM) CL+SSL::PTR CL+SSL::LEN)
; 
; note: doing SAP to pointer coercion (cost 20)
; 
; note: doing SAP to pointer coercion (cost 20)

;     (CFFI:FOREIGN-STRING-TO-LISP (CFFI:MEM-REF CL+SSL::PTR :POINTER) :COUNT
;                                  (CFFI:MEM-REF CL+SSL::LEN :INT))
; 
; note: doing SAP to pointer coercion (cost 20)

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

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/adw-charting/7a7e66124521f356ff6b6b9653f8b190b827b7e1/adw-charting-20250708-http/src/charting.lisp
; in: DEFCLASS AREA
;     (NET.ACCELERATION.CHARTING::HEIGHT :ACCESSOR
;      NET.ACCELERATION.CHARTING::HEIGHT :INITARG :HEIGHT :TYPE INTEGER :INITFORM
;      NIL)
; ==>
;   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)
; ==>
;   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 tid=1100583 "main thread" RUNNING {1200F08003}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "adw-charting" "src" "charting">

Backtrace for: #<SB-THREAD:THREAD tid=1100583 "main thread" RUNNING {1200F08003}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {122AEF7B63}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {122AEF7B63}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {122AEF7B63}>)
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 {120467F3A3}>) [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 {120467F3A3}>) [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) {120469BB0B}> :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) {1204652B0B}> :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-c9ttT9Wp/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-c9ttT9Wp/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-c9ttT9Wp/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-3" :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 1 STYLE-WARNING condition
;   printed 286 notes
adw-charting

adw-charting

adw-charting-vecto

adw-charting-google
