unicly

SBCL 2.0.2.48-acf667534 / ASDF 3.3.1

unicly

WARNING: UIOP/VERSION:PARSE-VERSION: "2011.08.31" contains leading zeros
WARNING: Invalid :version specifier "2011.08.31" for component "unicly" from file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly.asd", using NIL instead

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-types.lisp
; in: DEFUN UUID-DELIMITED-STRING-36-P
;     (CHAR UNICLY::STRING-SEQ UNICLY::SOURCE-IDX)
; --> AREF SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

;     (LOOP UNICLY::FOR CHAR UNICLY::ACROSS UNICLY::MAYBE-DELIM-STRING-36
;           UNICLY::THEREIS (CHAR= #\- CHAR))
; --> BLOCK LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

;     (LOOP UNICLY::INITIALLY (UNLESS
;                                 (LOOP UNICLY::FOR CHAR UNICLY::ACROSS UNICLY::MAYBE-DELIM-STRING-36
;                                       UNICLY::THEREIS (CHAR= #\- CHAR))
;                               (LOOP-FINISH))
;           UNICLY::FOR UNICLY::DELIM-CHAR UNICLY::ACROSS UNICLY::MAYBE-DELIM-STRING-36
;           UNICLY::FOR UNICLY::IDX UNICLY::FROM 0 UNICLY::BELOW ...)
; --> BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET 
; --> TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET 
; --> TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET 
; --> TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET 
; --> TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-types.lisp
; in: DEFUN UUID-HEX-STRING-36-P
;     (UNICLY::UUID-DELIMITED-STRING-36-P
;      (THE UNICLY::UUID-STRING-36 UNICLY::MAYBE-UUID-HEX-STRING-36))
; --> BLOCK LABELS LOOP BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET 
; --> SB-LOOP::WITH-SUM-COUNT LET TAGBODY UNLESS IF LOOP BLOCK LET LET LET 
; --> TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK LABELS LOOP BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET 
; --> SB-LOOP::WITH-SUM-COUNT LET TAGBODY UNLESS IF LOOP BLOCK LET LET LET 
; --> TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK LABELS LOOP BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET 
; --> SB-LOOP::WITH-SUM-COUNT LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK LABELS LOOP BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET 
; --> SB-LOOP::WITH-SUM-COUNT LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK LABELS LOOP BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET 
; --> SB-LOOP::WITH-SUM-COUNT LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK LABELS LOOP BLOCK LET LET LET SB-LOOP::WITH-SUM-COUNT LET 
; --> SB-LOOP::WITH-SUM-COUNT LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK LABELS UNICLY::DELIMIT-SEQ BLOCK LET LOOP BLOCK LET LET TAGBODY 
; --> SETF SB-KERNEL:%CHARSET SETF LET* CHAR AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFUN %UNIQUE-UNIVERSAL-IDENTIFIER-NULL-P
;     'UNICLY::UNIQUE-UNIVERSAL-IDENTIFIER-NULL
; 
; note: can't open-code test of unknown type UNIQUE-UNIVERSAL-IDENTIFIER-NULL

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFUN UNIQUE-UNIVERSAL-IDENTIFIER-NULL-P
;     (UNICLY::%UNIQUE-UNIVERSAL-IDENTIFIER-NULL-P UNICLY::OBJECT)
; --> BLOCK 
; ==>
;   (TYPEP UNICLY::OBJECT 'UNICLY::UNIQUE-UNIVERSAL-IDENTIFIER-NULL)
; 
; note: can't open-code test of unknown type UNIQUE-UNIVERSAL-IDENTIFIER-NULL

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFUN %MAKE-NULL-UUID-LOADTIME
;     (UNICLY::%UNIQUE-UNIVERSAL-IDENTIFIER-NULL-P UNICLY::*UUID-NULL-UUID*)
; --> BLOCK 
; ==>
;   (TYPEP UNICLY::OBJECT 'UNICLY::UNIQUE-UNIVERSAL-IDENTIFIER-NULL)
; 
; note: can't open-code test of unknown type UNIQUE-UNIVERSAL-IDENTIFIER-NULL

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFUN %VERIFY-SLOT-BOUNDP-AND-TYPE
;     (DEFUN UNICLY::%VERIFY-SLOT-BOUNDP-AND-TYPE (UNICLY::VERIFY-UUID)
;       (DECLARE (UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER UNICLY::VERIFY-UUID)
;                (OPTIMIZE SPEED))
;       (WITH-SLOTS ((UNICLY::UTL UNICLY::%UUID_TIME-LOW)
;                    (UNICLY::UTM UNICLY::%UUID_TIME-MID)
;                    (UNICLY::UTHAV UNICLY::%UUID_TIME-HIGH-AND-VERSION)
;                    (UNICLY::UCSAR UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED)
;                    (UNICLY::UCSL UNICLY::%UUID_CLOCK-SEQ-LOW)
;                    (UNICLY::UN UNICLY::%UUID_NODE))
;           UNICLY::VERIFY-UUID
;         (LOOP UNICLY::FOR (UNICLY::CHK-BND
;                            . UNICLY::CHK-TYPE) UNICLY::IN '((UNICLY::%UUID_TIME-LOW
;                                                              . UNICLY::UUID-UB32)
;                                                             (UNICLY::%UUID_TIME-MID
;                                                              . UNICLY::UUID-UB16)
;                                                             (UNICLY::%UUID_TIME-HIGH-AND-VERSION
;                                                              . UNICLY::UUID-UB16)
;                                                             (UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED
;                                                              . UNICLY::UUID-UB8)
;                                                             (UNICLY::%UUID_CLOCK-SEQ-LOW
;                                                              . UNICLY::UUID-UB8)
;                                                             (UNICLY::%UUID_NODE
;                                                              . UNICLY::UUID-UB48))
;               UNLESS (SLOT-BOUNDP UNICLY::VERIFY-UUID UNICLY::CHK-BND)
;               DO (ERROR 'UNICLY::UUID-SLOT-UNBOUND-ERROR :UUID-SLOT-UNBOUND-NAME
;                         UNICLY::CHK-BND :UUID-SLOT-UNBOUND-OBJECT
;                         UNICLY::VERIFY-UUID)
;               UNLESS (TYPEP (SLOT-VALUE UNICLY::VERIFY-UUID UNICLY::CHK-BND)
;                             UNICLY::CHK-TYPE)
;               DO ...)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; ==>
;   (SB-C::%FUNCALL #'%VERIFY-SLOT-BOUNDP-AND-TYPE #:G3)
; 
; note: can't open-code test of unknown type UNIQUE-UNIVERSAL-IDENTIFIER

;     (TYPEP (SLOT-VALUE UNICLY::VERIFY-UUID UNICLY::CHK-BND) UNICLY::CHK-TYPE)
; 
; note: unable to optimize because: can't open-code test of non-constant type

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFMETHOD UUID-PRINT-BYTES (T UNIQUE-UNIVERSAL-IDENTIFIER)
;     (WITH-SLOTS (UNICLY::%UUID_TIME-LOW UNICLY::%UUID_TIME-MID
;                  UNICLY::%UUID_TIME-HIGH-AND-VERSION
;                  UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED UNICLY::%UUID_CLOCK-SEQ-LOW
;                  UNICLY::%UUID_NODE)
;         UNICLY::UUID
;       (DECLARE (TYPE UNICLY::UUID-UB32 UNICLY::%UUID_TIME-LOW)
;                (TYPE UNICLY::UUID-UB16 UNICLY::%UUID_TIME-MID
;                 UNICLY::%UUID_TIME-HIGH-AND-VERSION)
;                (TYPE UNICLY::UUID-UB8 UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED
;                 UNICLY::%UUID_CLOCK-SEQ-LOW)
;                (TYPE UNICLY::UUID-UB48 UNICLY::%UUID_NODE))
;       (FORMAT STREAM "~(~8,'0X~4,'0X~4,'0X~2,'0X~2,'0X~12,'0X~)"
;               UNICLY::%UUID_TIME-LOW UNICLY::%UUID_TIME-MID
;               UNICLY::%UUID_TIME-HIGH-AND-VERSION
;               UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED UNICLY::%UUID_CLOCK-SEQ-LOW
;               UNICLY::%UUID_NODE))
; --> LET SYMBOL-MACROLET FORMAT 
; ==>
;   (FORMAT SB-C::DEST
;           (SB-INT:NAMED-LAMBDA "fmt$~(~8,'0X~4,'0X~4,'0X~2,'0X~2,'0X~12,'0X~)"
;               (STREAM SB-FORMAT::FORMAT-ARG1 SB-FORMAT::FORMAT-ARG2
;                SB-FORMAT::FORMAT-ARG3 SB-FORMAT::FORMAT-ARG4
;                SB-FORMAT::FORMAT-ARG5 SB-FORMAT::FORMAT-ARG6 &REST
;                SB-FORMAT::ARGS)
;             (DECLARE (IGNORABLE STREAM SB-FORMAT::ARGS))
;             (BLOCK NIL
;               (LET (#)
;                 (LET #
;                   #)
;                 (LET #
;                   #)
;                 (LET #
;                   #)
;                 (LET #
;                   #)
;                 (LET #
;                   #)
;                 (LET #
;                   #)))
;             NIL)
;           #:G8 #:G9 #:G10 #:G11 #:G12 #:G13)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STREAM BOOLEAN (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a STREAM.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STREAM BOOLEAN (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a (MEMBER T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STREAM BOOLEAN (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a NULL.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFMETHOD UUID-PRINT-BYTES-TO-STRING (UNIQUE-UNIVERSAL-IDENTIFIER)
;     (IF (AND (STRINGP UNICLY::STRING-OR-CHAR-TYPE)
;              (UNICLY::STRING-WITH-FILL-POINTER-CHECK-TYPE
;               UNICLY::STRING-OR-CHAR-TYPE))
;         UNICLY::STRING-OR-CHAR-TYPE
;         (MAKE-ARRAY 32 :ELEMENT-TYPE UNICLY::STRING-OR-CHAR-TYPE :FILL-POINTER 0))
; 
; note: deleting unreachable code

;     (COERCE (NSTRING-UPCASE UNICLY::FP-STRM :START 0 :END 32) 'SIMPLE-BASE-STRING)
; --> THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE 'BASE-CHAR) SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (AND (SATISFIES SB-IMPL::VECTOR-WITH-FILL-POINTER-P) (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (SATISFIES SB-IMPL::VECTOR-WITH-FILL-POINTER-P) (NOT SIMPLE-BASE-STRING) (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a (SIMPLE-ARRAY CHARACTER (*)).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFMETHOD UUID-PRINT-BYTES-TO-STRING (VECTOR)
;     (FORMAT UNICLY::FP-STRM
;             (IRONCLAD:BYTE-ARRAY-TO-HEX-STRING UNICLY::UUID :START 0 :END 16
;                                                :ELEMENT-TYPE
;                                                (IF (STRINGP
;                                                     UNICLY::STRING-OR-CHAR-TYPE)
;                                                    (ARRAY-ELEMENT-TYPE
;                                                     UNICLY::STRING-OR-CHAR-TYPE)
;                                                    UNICLY::STRING-OR-CHAR-TYPE)))
; 
; note: unable to optimize because: The control string is not a constant.

;     (COERCE (NSTRING-UPCASE UNICLY::FP-STRM :START 0 :END 32) 'SIMPLE-BASE-STRING)
; --> THE IF 
; ==>
;   (REPLACE (MAKE-ARRAY (LENGTH SB-C::X) :ELEMENT-TYPE 'BASE-CHAR) SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (NOT SIMPLE-BASE-STRING) (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a (SIMPLE-ARRAY CHARACTER (*)).

;     (MAKE-ARRAY 32 :ELEMENT-TYPE UNICLY::STRING-OR-CHAR-TYPE :FILL-POINTER 0)
; 
; note: unable to optimize because: ELEMENT-TYPE is not constant.

;     (IF (AND (STRINGP UNICLY::STRING-OR-CHAR-TYPE)
;              (UNICLY::STRING-WITH-FILL-POINTER-CHECK-TYPE
;               UNICLY::STRING-OR-CHAR-TYPE)
;              (MEMBER (ARRAY-ELEMENT-TYPE UNICLY::STRING-OR-CHAR-TYPE)
;                      '(BASE-CHAR CHARACTER)))
;         UNICLY::STRING-OR-CHAR-TYPE
;         (MAKE-ARRAY 32 :ELEMENT-TYPE UNICLY::STRING-OR-CHAR-TYPE :FILL-POINTER 0))
; ==>
;   UNICLY::STRING-OR-CHAR-TYPE
; 
; note: could not stack allocate STRING-OR-CHAR-TYPE in: (IF (AND (STRINGP STRING-OR-CHAR-TYPE) (STRING-WITH-FILL-POINTER-CHECK-TYPE STRING-OR-CHAR-TYPE) (MEMBER (ARRAY-ELEMENT-TYPE STRING-OR-CHAR-TYPE) (QUOTE (BASE-CHAR CHARACTER)))) STRING-OR-CHAR-TYPE (MAKE-ARRAY 32 :ELEMENT-TYPE STRING-OR-CHAR-TYPE :FILL-POINTER 0))

;     (MAKE-ARRAY 32 :ELEMENT-TYPE UNICLY::STRING-OR-CHAR-TYPE :FILL-POINTER 0)
; 
; note: could not stack allocate: (MAKE-ARRAY 32 :ELEMENT-TYPE STRING-OR-CHAR-TYPE :FILL-POINTER 0)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-class.lisp
; in: DEFUN UUID-COPY-UUID
;     (UNICLY::%UNIQUE-UNIVERSAL-IDENTIFIER-NULL-P UNICLY::UUID-INSTANCE)
; --> BLOCK 
; ==>
;   (TYPEP UNICLY::OBJECT 'UNICLY::UNIQUE-UNIVERSAL-IDENTIFIER-NULL)
; 
; note: can't open-code test of unknown type UNIQUE-UNIVERSAL-IDENTIFIER-NULL

;     (DEFUN UNICLY:UUID-COPY-UUID (UNICLY::UUID-INSTANCE)
;       (DECLARE (UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER UNICLY::UUID-INSTANCE)
;                (OPTIMIZE (SPEED 3)))
;       (WHEN (UNICLY::%UNIQUE-UNIVERSAL-IDENTIFIER-NULL-P UNICLY::UUID-INSTANCE)
;         (RETURN-FROM UNICLY:UUID-COPY-UUID
;           (MAKE-INSTANCE 'UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER)))
;       (UNICLY::%VERIFY-SLOT-BOUNDP-AND-TYPE UNICLY::UUID-INSTANCE)
;       (WITH-SLOTS (UNICLY::%UUID_TIME-LOW UNICLY::%UUID_TIME-MID
;                    UNICLY::%UUID_TIME-HIGH-AND-VERSION
;                    UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED
;                    UNICLY::%UUID_CLOCK-SEQ-LOW UNICLY::%UUID_NODE)
;           UNICLY::UUID-INSTANCE
;         (DECLARE (TYPE UNICLY::UUID-UB32 UNICLY::%UUID_TIME-LOW)
;                  (TYPE UNICLY::UUID-UB16 UNICLY::%UUID_TIME-MID
;                   UNICLY::%UUID_TIME-HIGH-AND-VERSION)
;                  (TYPE UNICLY::UUID-UB8 UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED
;                   UNICLY::%UUID_CLOCK-SEQ-LOW)
;                  (TYPE UNICLY::UUID-UB48 UNICLY::%UUID_NODE))
;         (MAKE-INSTANCE 'UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER :%UUID_TIME-LOW
;                        UNICLY::%UUID_TIME-LOW :%UUID_TIME-MID
;                        UNICLY::%UUID_TIME-MID :%UUID_TIME-HIGH-AND-VERSION
;                        UNICLY::%UUID_TIME-HIGH-AND-VERSION
;                        :%UUID_CLOCK-SEQ-AND-RESERVED
;                        UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED :%UUID_CLOCK-SEQ-LOW
;                        UNICLY::%UUID_CLOCK-SEQ-LOW ...)))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; ==>
;   (SB-C::%FUNCALL #'UUID-COPY-UUID #:G3)
; 
; note: can't open-code test of unknown type UNIQUE-UNIVERSAL-IDENTIFIER

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-byte-arrays.lisp
; in: DEFUN UUID-BYTE-ARRAY-16-TO-INTEGER
;     (ASH UNICLY::SUM 8)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (+ (AREF UNICLY::UUID-BA-16 UNICLY::J) (ASH UNICLY::SUM 8))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 4) because:
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in:
;      DECLAIM (INLINE UUID-BIT-VECTOR-128-ZEROED UUID-BIT-VECTOR-48-ZEROED UUID-BIT-VECTOR-32-ZEROED UUID-BIT-VECTOR-16-ZEROED UUID-BIT-VECTOR-8-ZEROED)
;     (DECLAIM
;      (INLINE UNICLY::UUID-BIT-VECTOR-128-ZEROED UNICLY::UUID-BIT-VECTOR-48-ZEROED
;       UNICLY::UUID-BIT-VECTOR-32-ZEROED UNICLY::UUID-BIT-VECTOR-16-ZEROED
;       UNICLY::UUID-BIT-VECTOR-8-ZEROED))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM
;    '(INLINE UNICLY::UUID-BIT-VECTOR-128-ZEROED
;      UNICLY::UUID-BIT-VECTOR-48-ZEROED UNICLY::UUID-BIT-VECTOR-32-ZEROED
;      UNICLY::UUID-BIT-VECTOR-16-ZEROED UNICLY::UUID-BIT-VECTOR-8-ZEROED)
;    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming UNICLY::UUID-BIT-VECTOR-128-ZEROED to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DEFUN UUID-BIT-VECTOR-TO-BYTE-ARRAY
;     (BIT UNICLY::BV8 UNICLY::I)
; --> AREF SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (BIT-VECTOR 8), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DECLAIM (INLINE UUID-VERSION-BIT-VECTOR)
;     (DECLAIM (INLINE UNICLY::UUID-VERSION-BIT-VECTOR))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE UNICLY::UUID-VERSION-BIT-VECTOR)
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming UNICLY::UUID-VERSION-BIT-VECTOR to be INLINE, but 3 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DEFUN UUID-INTEGER-128-TO-BIT-VECTOR
;     (INTEGER-LENGTH UNICLY::UUID-INTEGER-128)
; 
; note: forced to do full call
;       unable to do inline positive fixnum integer-length (cost 24) because:
;       The first argument is a (UNSIGNED-BYTE 128), not a (UNSIGNED-BYTE 62).
;       unable to do inline fixnum integer-length (cost 25) because:
;       The first argument is a (UNSIGNED-BYTE 128), not a FIXNUM.
;       etc.

;     (DEFUN UNICLY::UUID-INTEGER-128-TO-BIT-VECTOR (UNICLY::UUID-INTEGER-128)
;       (DECLARE (UNICLY::UUID-UB128 UNICLY::UUID-INTEGER-128)
;                (OPTIMIZE (SPEED 3)))
;       (LET ((UNICLY::MK-BIG-LEN (THE UNICLY::UUID-UB128-INTEGER-LENGTH #))
;             (UNICLY::BV-BIG (THE UNICLY::UUID-BIT-VECTOR-128 #)))
;         (DECLARE (UNICLY::UUID-UB128-INTEGER-LENGTH UNICLY::MK-BIG-LEN)
;                  (UNICLY::UUID-BIT-VECTOR-128 UNICLY::BV-BIG))
;         (LOOP UNICLY::FOR UNICLY::I-LB UNICLY::FROM 0 UNICLY::BELOW UNICLY::MK-BIG-LEN
;               DO (AND (LOGBITP UNICLY::I-LB UNICLY::UUID-INTEGER-128) (SETF #))
;               UNICLY::FINALLY (RETURN (NREVERSE UNICLY::BV-BIG)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-C::%FUNCALL MULTIPLE-VALUE-BIND LET UNLESS IF AND IF LOCALLY AND IF >= 
; --> IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DEFUN UUID-BIT-VECTOR-TO-INTEGER
;     (< UNICLY::INDEX (1- UNICLY::BV-LENGTH))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

;     (INCF UNICLY::INDEX)
; --> SETQ THE 
; ==>
;   (+ 1 UNICLY::INDEX)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (THE UNICLY::UUID-UB128 (UNICLY::LOOP-AND-RETURN))
; --> MULTIPLE-VALUE-BIND LET UNLESS IF AND IF LOCALLY AND IF >= IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do FAST-IF-<-ZERO (cost 9)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (LOOP UNICLY::REPEAT UNICLY::WORD-SIZE
;           UNICLY::FOR UNICLY::J = 0 UNICLY::THEN (LOGIOR
;                                                   (SBIT BIT-VECTOR
;                                                         (INCF UNICLY::INDEX))
;                                                   (ASH UNICLY::J 1))
;           UNICLY::FINALLY (RETURN UNICLY::J))
; --> BLOCK LET TAGBODY IF <= IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do FAST-IF->-ZERO (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.

;     (ASH UNICLY::RESULT (1- UNICLY::WORD-SIZE))
; 
; 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 (INTEGER -1 63), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a (INTEGER -1 63), not a (UNSIGNED-BYTE 62).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOGIOR (UNICLY::BUILD-WORD) (ASH UNICLY::RESULT (1- UNICLY::WORD-SIZE)))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR INTEGER NULL), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The first argument is a (OR INTEGER NULL), not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (LOOP UNICLY::REPEAT UNICLY::WORD-SIZE
;           UNICLY::FOR UNICLY::J = 0 UNICLY::THEN (LOGIOR
;                                                   (SBIT BIT-VECTOR
;                                                         (INCF UNICLY::INDEX))
;                                                   (ASH UNICLY::J 1))
;           UNICLY::FINALLY (RETURN UNICLY::J))
; --> BLOCK 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 &REST T).
;       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 &REST T).
;       etc.

;     (INCF UNICLY::INDEX)
; --> SETQ THE 
; ==>
;   (+ 1 UNICLY::INDEX)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH UNICLY::J 1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a (OR INTEGER NULL), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a (OR INTEGER NULL), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (LOGIOR (SBIT BIT-VECTOR (INCF UNICLY::INDEX)) (ASH UNICLY::J 1))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

;     (< UNICLY::INDEX (1- UNICLY::BV-LENGTH))
; 
; 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 UNICLY::INDEX)
; --> SETQ THE 
; ==>
;   (+ 1 UNICLY::INDEX)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (ASH UNICLY::RESULT 1)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &REST T).
;       etc.

;     (LOGIOR (SBIT BIT-VECTOR (INCF UNICLY::INDEX)) (ASH UNICLY::RESULT 1))
; 
; note: forced to do full call
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 3) because:
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DEFUN UUID-BIT-VECTOR-BUILD-OFFSETS
;     (+ UNICLY::X 7)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 7) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 7) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP UNICLY::FOR UNICLY::X UNICLY::FROM UNICLY::BIT-OFFSET UNICLY::BELOW (+
;                                                                                UNICLY::BIT-OFFSET
;                                                                                UNICLY::BIT-WIDTH) UNICLY::BY 8
;           UNICLY::FOR UNICLY::Q = ...)
; --> BLOCK LET LET LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE 
; ==>
;   (+ UNICLY::X 8)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 8) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 8) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> BLOCK LET LET LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY 
; --> WHEN IF >= IF 
; ==>
;   (< SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (INTEGER 8), not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DEF-UUID-REQUEST-INTEGER-BIT-VECTOR "time-mid"
;     (UNICLY::DEF-UUID-REQUEST-INTEGER-BIT-VECTOR "time-mid" 32 16)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LOOP BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY 
; --> RETURN RETURN-FROM 
; ==>
;   (THE UNICLY::UUID-UB16 (APPLY #'UNICLY::UUID-ASSEMBLE-UB16 UNICLY::BYTES))
; 
; note: type assertion too complex to check:
; (VALUES (UNSIGNED-BYTE 16) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DEF-UUID-REQUEST-INTEGER-BIT-VECTOR "time-high-and-version"
;     (UNICLY::DEF-UUID-REQUEST-INTEGER-BIT-VECTOR "time-high-and-version" 48 16)
; --> DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA FUNCTION 
; --> BLOCK LOOP BLOCK LET SB-LOOP::WITH-LOOP-LIST-COLLECTION-HEAD LET* TAGBODY 
; --> RETURN RETURN-FROM 
; ==>
;   (THE UNICLY::UUID-UB16 (APPLY #'UNICLY::UUID-ASSEMBLE-UB16 UNICLY::BYTES))
; 
; note: type assertion too complex to check:
; (VALUES (UNSIGNED-BYTE 16) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-bit-vectors.lisp
; in: DEFUN UUID-FROM-BIT-VECTOR
;     (THE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER (UNICLY:MAKE-NULL-UUID))
; 
; note: type assertion too complex to check:
; (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &REST T).

;     (THE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;          (MAKE-INSTANCE 'UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER :%UUID_TIME-LOW
;                         UNICLY::TL :%UUID_TIME-MID UNICLY::TM
;                         :%UUID_TIME-HIGH-AND-VERSION UNICLY::THV
;                         :%UUID_CLOCK-SEQ-AND-RESERVED UNICLY::CSR
;                         :%UUID_CLOCK-SEQ-LOW UNICLY::CSL ...))
; 
; note: type assertion too complex to check:
; (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &REST T).
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "unicly" "unicly-bit-vectors">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly.lisp
; in: DEFUN UUID-DIGEST-UUID-INSTANCE
;     (DEFUN UNICLY::UUID-DIGEST-UUID-INSTANCE
;            (UNICLY::DIGEST-VERSION UNICLY::UUID-NAMESPACE-INSTANCE UNICLY::NAME)
;       (DECLARE (TYPE (MOD 6) UNICLY::DIGEST-VERSION)
;                (UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;                 UNICLY::UUID-NAMESPACE-INSTANCE)
;                (TYPE UNICLY::STRING-COMPAT UNICLY::NAME)
;                (INLINE UNICLY::%UUID-STRING-TO-OCTETS
;                 UNICLY::%VERIFY-DIGEST-VERSION
;                 UNICLY::%UUID-DIGEST-UUID-INSTANCE-SHA1
;                 UNICLY::%UUID-DIGEST-UUID-INSTANCE-MD5)
;                (OPTIMIZE (SPEED 3)))
;       (MULTIPLE-VALUE-BIND (UNICLY::UUID-BA UNICLY::NAME-BA)
;           (THE
;            (VALUES UNICLY::UUID-BYTE-ARRAY-16 UNICLY::UUID-BYTE-ARRAY &OPTIONAL)
;            (UNICLY::VERIFY-SANE-NAMESPACE-AND-NAME
;             UNICLY::UUID-NAMESPACE-INSTANCE UNICLY::NAME))
;         (DECLARE (UNICLY::UUID-BYTE-ARRAY-16 UNICLY::UUID-BA)
;                  (UNICLY::UUID-BYTE-ARRAY UNICLY::NAME-BA))
;         (ECASE (UNICLY::%VERIFY-DIGEST-VERSION UNICLY::DIGEST-VERSION)
;           (:MD5 (THE # #))
;           (:SHA1 (THE # #)))))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'UNICLY::UUID-DIGEST-UUID-INSTANCE
;                    (SB-INT:NAMED-LAMBDA UNICLY::UUID-DIGEST-UUID-INSTANCE
;                        (UNICLY::DIGEST-VERSION UNICLY::UUID-NAMESPACE-INSTANCE
;                         UNICLY::NAME)
;                      (DECLARE (SB-C::TOP-LEVEL-FORM))
;                      (DECLARE (TYPE (MOD 6) UNICLY::DIGEST-VERSION)
;                               (UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;                                UNICLY::UUID-NAMESPACE-INSTANCE)
;                               (TYPE UNICLY::STRING-COMPAT UNICLY::NAME)
;                               (INLINE UNICLY::%UUID-STRING-TO-OCTETS
;                                UNICLY::%VERIFY-DIGEST-VERSION
;                                UNICLY::%UUID-DIGEST-UUID-INSTANCE-SHA1
;                                UNICLY::%UUID-DIGEST-UUID-INSTANCE-MD5)
;                               (OPTIMIZE (SPEED 3)))
;                      (BLOCK UNICLY::UUID-DIGEST-UUID-INSTANCE
;                        (MULTIPLE-VALUE-BIND (UNICLY::UUID-BA UNICLY::NAME-BA)
;                            (THE # #)
;                          (DECLARE #
;                                   #)
;                          (ECASE # # #)))))
; 
; caught STYLE-WARNING:
;   Call to UNICLY::%UUID-DIGEST-UUID-INSTANCE-MD5 could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly.lisp
; in: DEFUN DIGESTED-V5-UUID
;     (THE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;          (MAKE-INSTANCE 'UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER :%UUID_TIME-LOW
;                         (UNICLY::%UUID_TIME-LOW-REQUEST
;                          UNICLY::V5-DIGEST-BYTE-ARRAY)
;                         :%UUID_TIME-MID
;                         (UNICLY::%UUID_TIME-MID-REQUEST
;                          UNICLY::V5-DIGEST-BYTE-ARRAY)
;                         :%UUID_TIME-HIGH-AND-VERSION
;                         (UNICLY::%UUID_TIME-HIGH-AND-VERSION-REQUEST
;                          UNICLY::V5-DIGEST-BYTE-ARRAY 5)
;                         :%UUID_CLOCK-SEQ-AND-RESERVED
;                         (UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED-REQUEST
;                          UNICLY::V5-DIGEST-BYTE-ARRAY)
;                         :%UUID_CLOCK-SEQ-LOW
;                         (THE UNICLY::UUID-UB8
;                              (UNICLY::%UUID_CLOCK-SEQ-LOW-REQUEST
;                               UNICLY::V5-DIGEST-BYTE-ARRAY))
;                         ...))
; 
; note: type assertion too complex to check:
; (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly.lisp
; in: DEFUN DIGESTED-V3-UUID
;     (THE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;          (MAKE-INSTANCE 'UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER :%UUID_TIME-LOW
;                         (UNICLY::%UUID_TIME-LOW-REQUEST
;                          UNICLY::V3-DIGEST-BYTE-ARRAY)
;                         :%UUID_TIME-MID
;                         (UNICLY::%UUID_TIME-MID-REQUEST
;                          UNICLY::V3-DIGEST-BYTE-ARRAY)
;                         :%UUID_TIME-HIGH-AND-VERSION
;                         (UNICLY::%UUID_TIME-HIGH-AND-VERSION-REQUEST
;                          UNICLY::V3-DIGEST-BYTE-ARRAY 3)
;                         :%UUID_CLOCK-SEQ-AND-RESERVED
;                         (UNICLY::%UUID_CLOCK-SEQ-AND-RESERVED-REQUEST
;                          UNICLY::V3-DIGEST-BYTE-ARRAY)
;                         :%UUID_CLOCK-SEQ-LOW
;                         (UNICLY::%UUID_CLOCK-SEQ-LOW-REQUEST
;                          UNICLY::V3-DIGEST-BYTE-ARRAY)
;                         ...))
; 
; note: type assertion too complex to check:
; (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly.lisp
; in: DEFUN MAKE-V5-UUID
;     (DEFUN UNICLY:MAKE-V5-UUID (UNICLY::NAMESPACE UNICLY::NAME)
;       (DECLARE (TYPE UNICLY::STRING-COMPAT UNICLY::NAME)
;                (TYPE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER UNICLY::NAMESPACE)
;                (INLINE UNICLY::UUID-DIGEST-UUID-INSTANCE
;                 UNICLY::DIGESTED-V3OR5-UUID)
;                (OPTIMIZE (SPEED 3)))
;       (THE (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &OPTIONAL)
;            (UNICLY::DIGESTED-V3OR5-UUID
;             (THE UNICLY::UUID-BYTE-ARRAY-20
;                  (UNICLY::UUID-DIGEST-UUID-INSTANCE 5 UNICLY::NAMESPACE
;                   UNICLY::NAME))
;             5)))
; --> PROGN 
; ==>
;   (SB-IMPL::%DEFUN 'UNICLY:MAKE-V5-UUID
;                    (SB-INT:NAMED-LAMBDA UNICLY:MAKE-V5-UUID
;                        (UNICLY::NAMESPACE UNICLY::NAME)
;                      (DECLARE (SB-C::TOP-LEVEL-FORM))
;                      (DECLARE (TYPE UNICLY::STRING-COMPAT UNICLY::NAME)
;                               (TYPE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;                                UNICLY::NAMESPACE)
;                               (INLINE UNICLY::UUID-DIGEST-UUID-INSTANCE
;                                UNICLY::DIGESTED-V3OR5-UUID)
;                               (OPTIMIZE (SPEED 3)))
;                      (BLOCK UNICLY:MAKE-V5-UUID
;                        (THE
;                         (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &OPTIONAL)
;                         (UNICLY::DIGESTED-V3OR5-UUID # 5)))))
; 
; caught STYLE-WARNING:
;   Call to UNICLY::UUID-DIGEST-UUID-INSTANCE could not be inlined because its source code was not saved. A global INLINE or SB-EXT:MAYBE-INLINE proclamation must be in effect to save function definitions for inlining.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly.lisp
; in: DEFUN MAKE-V4-UUID
;     (THE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;          (MAKE-INSTANCE 'UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER :%UUID_TIME-LOW
;                         (THE UNICLY::UUID-UB32 (RANDOM 4294967295))
;                         :%UUID_TIME-MID (THE UNICLY::UUID-UB16 (RANDOM 65535))
;                         :%UUID_TIME-HIGH-AND-VERSION
;                         (THE UNICLY::UUID-UB16 (DPB 4 (BYTE 4 12) (LDB # #)))
;                         :%UUID_CLOCK-SEQ-AND-RESERVED
;                         (THE UNICLY::UUID-UB8 (DPB 2 (BYTE 2 6) (LDB # #)))
;                         :%UUID_CLOCK-SEQ-LOW (THE UNICLY::UUID-UB8 (RANDOM 255))
;                         ...))
; 
; note: type assertion too complex to check:
; (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly.lisp
; in: DEFUN UUID-AS-URN-STRING
;     (FORMAT STREAM "~(urn:uuid:~A~)" UNICLY::UUID)
; ==>
;   (FORMAT SB-C::DEST
;           (SB-INT:NAMED-LAMBDA "fmt$~(urn:uuid:~A~)"
;               (STREAM SB-FORMAT::FORMAT-ARG1 &REST SB-FORMAT::ARGS)
;             (DECLARE (IGNORABLE STREAM SB-FORMAT::ARGS))
;             (BLOCK NIL
;               (LET (#)
;                 (WRITE-STRING "urn:uuid:" STREAM)
;                 (PRINC SB-FORMAT::FORMAT-ARG1 STREAM)))
;             NIL)
;           #:G3)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STREAM BOOLEAN (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a STREAM.
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STREAM BOOLEAN (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a (MEMBER T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR STREAM BOOLEAN (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) (VECTOR CHARACTER)) (AND (SATISFIES VECTOR-WITH-FILL-POINTER-P) BASE-STRING)), not a NULL.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "unicly" "unicly">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-string-uuid.lisp
; in: DEFUN MAKE-UUID-FROM-STRING-IF
;     (UNICLY:UUID-HEX-STRING-36-P UNICLY::UUID-HEX-STRING-36-IF)
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS UNICLY::DELIMIT-SEQ BLOCK 
; --> LET LOOP BLOCK LET LET TAGBODY SETF SB-KERNEL:%CHARSET SETF LET* CHAR 
; --> AREF SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY UNLESS IF 
; --> LOOP BLOCK LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY UNLESS IF 
; --> LOOP BLOCK LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-string-uuid.lisp
; in: DEFUN MAKE-UUID-FROM-STRING
;     (THE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;          (MAKE-INSTANCE 'UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER :%UUID_TIME-LOW
;                         (UNICLY::UUID-HEX-VECTOR-PARSE-TIME-LOW
;                          UNICLY::CHK-UUID-STR)
;                         :%UUID_TIME-MID
;                         (UNICLY::UUID-HEX-VECTOR-PARSE-TIME-MID
;                          UNICLY::CHK-UUID-STR)
;                         :%UUID_TIME-HIGH-AND-VERSION
;                         (UNICLY::UUID-HEX-VECTOR-PARSE-TIME-HIGH-AND-VERSION
;                          UNICLY::CHK-UUID-STR)
;                         :%UUID_CLOCK-SEQ-AND-RESERVED
;                         (UNICLY::UUID-HEX-VECTOR-PARSE-CLOCK-SEQ-AND-RESERVED
;                          UNICLY::CHK-UUID-STR)
;                         :%UUID_CLOCK-SEQ-LOW
;                         (UNICLY::UUID-HEX-VECTOR-PARSE-CLOCK-SEQ-LOW
;                          UNICLY::CHK-UUID-STR)
;                         ...))
; 
; note: type assertion too complex to check:
; (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &REST T).

;     (THE UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER
;          (UNICLY:UUID-COPY-UUID UNICLY::UUID-OR-HEX-STRING-36))
; 
; note: type assertion too complex to check:
; (VALUES UNICLY:UNIQUE-UNIVERSAL-IDENTIFIER &REST T).

;     (UNICLY::MAKE-UUID-FROM-STRING-IF UNICLY::UUID-OR-HEX-STRING-36)
; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF UNICLY:UUID-STRING-36-P BLOCK TYPEP LET 
; --> SB-C::%TYPEP-WRAPPER AND IF IF = IF = 
; ==>
;   (SB-KERNEL:%ARRAY-DIMENSION (TRULY-THE (VECTOR CHARACTER) #:OBJECT21) 0)
; 
; note: unable to optimize because: don't know how to extract array dimensions from type (OR UNIQUE-UNIVERSAL-IDENTIFIER (VECTOR CHARACTER) (VECTOR NIL) BASE-STRING)

; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS UNICLY::DELIMIT-SEQ BLOCK 
; --> LET LOOP BLOCK LET LET TAGBODY SETF SB-KERNEL:%CHARSET SETF LET* CHAR 
; --> AREF SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY UNLESS IF 
; --> LOOP BLOCK LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY UNLESS IF 
; --> LOOP BLOCK LET LET LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF SB-KERNEL:CHECK-BOUND SB-C::BOUND-CAST 
; ==>
;   (SB-KERNEL:%CHECK-BOUND ARRAY SB-C::DIMENSION SB-INT:INDEX)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a (SIMPLE-ARRAY * (*)).

; --> BLOCK MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL UNICLY:UUID-HEX-STRING-36-P 
; --> BLOCK WHEN IF MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> UNICLY::UUID-DELIMITED-STRING-36-P BLOCK LABELS LOOP BLOCK LET LET LET 
; --> SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY 
; --> SB-LOOP::LOOP-DESETQ SETQ THE AREF 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-STRING.
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR CHARACTER 36), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/unicly/74a73d2f1507e0bd808aefffa5e7519ccadcdfbb/unicly-20200311-git/unicly-hash-table.lisp
; in: DEFUN SXHASH-UUID
;     (LOGAND UNICLY::NODE-INT
;             (DPB -1
;                  (BYTE (THE (MOD 49) UNICLY::+%%UUID-SXHASH-TRUNCATING-NODE%%+)
;                        0)
;                  0))
; ==>
;   UNICLY::NODE-INT
; 
; note: deleting unreachable code
; 
; caught ERROR:
;   READ error during COMPILE-FILE: Lock on package SB-IMPL violated when interning +MIN-HASH-TABLE-SIZE+ while in package UNICLY.
;   See also:
;     The SBCL Manual, Node "Package Locks"(in form starting at line: 148, column: 0, position: 7485)
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {1000520083}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "unicly" "unicly-hash-table">

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {1000520083}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1005E12933}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1005E12933}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {1005E12933}>)
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 "unicly" "unicly-hash-table">)))
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 "unicly" "unicly-hash-table">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "unicly" "unicly-hash-table">)
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 "unicly" "unicly-hash-table">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005123C63}>) [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 {1005123C63}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "unicly"> :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 "unicly">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "unicly">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "unicly")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "unicly") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100511F49B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10050D70AB}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "unicly") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "unicly" "unicly")
23: (DEPCHECK::MAGIC "unicly" "unicly" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-77tmGRpx/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "unicly" "unicly" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-77tmGRpx/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-77tmGRpx/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-7" :IN SAVE-LISP-AND-DIE))
28: ((LABELS SB-IMPL::RESTART-LISP :IN SAVE-LISP-AND-DIE))

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