cepl.camera

SBCL 1.4.4 / ASDF 3.3.1

cepl.camera

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-ppcre/3d57f1e446e4894097acebf36d52978ddaa62531/cl-ppcre-20180224-git/cl-ppcre.asd" contains definition for system "cl-ppcre-test". Please only define "cl-ppcre" and secondary systems with a name starting with "cl-ppcre/" (e.g. "cl-ppcre/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/ieee-floats/fa9e496f0fcf4ba05754fc32787f728ca6e2d674/ieee-floats-20180224-git/ieee-floats.asd" contains definition for system "ieee-floats-tests". Please only define "ieee-floats" and secondary systems with a name starting with "ieee-floats/" (e.g. "ieee-floats/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/parse-float/c280e2e4f7fd153d0ddec5de03f56b0891f33e24/parse-float-20180224-git/parse-float.asd" contains definition for system "parse-float-tests". Please only define "parse-float" and secondary systems with a name starting with "parse-float/" (e.g. "parse-float/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/parse-float/c280e2e4f7fd153d0ddec5de03f56b0891f33e24/parse-float-20180224-git/parse-float.lisp
; in: DEFUN SKIP-WHITESPACES
;     (CHAR STRING PARSE-FLOAT::INDEX)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/parse-float/c280e2e4f7fd153d0ddec5de03f56b0891f33e24/parse-float-20180224-git/parse-float.lisp
; in: DEFUN PARSE-INTEGER-ONLY
;     (CHAR STRING PARSE-FLOAT::INDEX)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (CHAR STRING POSITION)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/parse-float/c280e2e4f7fd153d0ddec5de03f56b0891f33e24/parse-float-20180224-git/parse-float.lisp
; in: DEFUN PARSE-FLOAT
;     (EXPT (COERCE PARSE-FLOAT::RADIX TYPE) (COERCE (- PARSE-FLOAT::DIGITS) TYPE))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (SINGLE-FLOAT 0.0).The second argument is a NUMBER, not a SINGLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (DOUBLE-FLOAT 0.0d0).The second argument is a NUMBER, not a DOUBLE-FLOAT.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (SINGLE-FLOAT 0.0).The second argument is a NUMBER, not a (SIGNED-BYTE 32).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (DOUBLE-FLOAT 0.0d0).The second argument is a NUMBER, not a (SIGNED-BYTE 32).

;     (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;        (EXPT (COERCE PARSE-FLOAT::RADIX TYPE)
;              (COERCE (- PARSE-FLOAT::DIGITS) TYPE)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (* PARSE-FLOAT::SIGN
;        (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;           (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;              (EXPT (COERCE PARSE-FLOAT::RADIX TYPE) (COERCE # TYPE))))
;        (EXPT 10 (COERCE PARSE-FLOAT::EXPONENT-PART TYPE)))
; --> * 
; ==>
;   (* PARSE-FLOAT::SIGN
;      (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;         (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;            (EXPT (COERCE PARSE-FLOAT::RADIX TYPE) (COERCE # TYPE)))))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The second argument is a NUMBER, not a INTEGER.

;     (EXPT 10 (COERCE PARSE-FLOAT::EXPONENT-PART TYPE))
; 
; note: unable to optimize due to type uncertainty: The second argument is a NUMBER, not a INTEGER.
; 
; note: unable to optimize due to type uncertainty: The second argument is a NUMBER, not a UNSIGNED-BYTE.

;     (* PARSE-FLOAT::SIGN
;        (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;           (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;              (EXPT (COERCE PARSE-FLOAT::RADIX TYPE) (COERCE # TYPE))))
;        (EXPT 10 (COERCE PARSE-FLOAT::EXPONENT-PART TYPE)))
; ==>
;   (*
;    (* PARSE-FLOAT::SIGN
;       (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;          (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE) (EXPT # #))))
;    (EXPT 10 (COERCE PARSE-FLOAT::EXPONENT-PART TYPE)))
; 
; note: unable to convert x*2^k to shift due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.

;     (CHAR STRING PARSE-FLOAT::INDEX)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (CHAR-EQUAL (CHAR STRING PARSE-FLOAT::INDEX) PARSE-FLOAT::EXPONENT-CHARACTER)
; ==>
;   (SB-INT:TWO-ARG-CHAR-EQUAL (CHAR STRING PARSE-FLOAT::INDEX)
;                              PARSE-FLOAT::EXPONENT-CHARACTER)
; 
; note: unable to open code due to type uncertainty: The first argument is a CHARACTER, not a BASE-CHAR.The second argument is a CHARACTER, not a BASE-CHAR.

;     (CHAR STRING PARSE-FLOAT::INDEX)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (CHAR-EQUAL CHAR PARSE-FLOAT::EXPONENT-CHARACTER)
; ==>
;   (SB-INT:TWO-ARG-CHAR-EQUAL CHAR PARSE-FLOAT::EXPONENT-CHARACTER)
; 
; note: unable to open code due to type uncertainty: The first argument is a CHARACTER, not a BASE-CHAR.The second argument is a CHARACTER, not a BASE-CHAR.

;     (PARSE-FLOAT::SKIP-WHITESPACES STRING :START PARSE-FLOAT::START :END
;      PARSE-FLOAT::END)
; --> BLOCK LOOP BLOCK LET TAGBODY UNLESS IF AND IF 
; --> PARSE-FLOAT::WHITESPACE-CHAR-P CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (CHAR STRING PARSE-FLOAT::INDEX)
; --> AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (PARSE-FLOAT::SKIP-WHITESPACES STRING :START PARSE-FLOAT::INDEX :END
;      PARSE-FLOAT::END)
; --> BLOCK LOOP BLOCK LET TAGBODY UNLESS IF AND IF 
; --> PARSE-FLOAT::WHITESPACE-CHAR-P CHAR AREF 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;        (EXPT (COERCE PARSE-FLOAT::RADIX TYPE)
;              (COERCE (- PARSE-FLOAT::DIGITS) TYPE)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;        (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;           (EXPT (COERCE PARSE-FLOAT::RADIX TYPE)
;                 (COERCE (- PARSE-FLOAT::DIGITS) TYPE))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

;     (* PARSE-FLOAT::SIGN
;        (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;           (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;              (EXPT (COERCE PARSE-FLOAT::RADIX TYPE) (COERCE # TYPE))))
;        (EXPT 10 (COERCE PARSE-FLOAT::EXPONENT-PART TYPE)))
; --> * 
; ==>
;   (* PARSE-FLOAT::SIGN
;      (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;         (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE)
;            (EXPT (COERCE PARSE-FLOAT::RADIX TYPE) (COERCE # TYPE)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The second argument is a NUMBER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; ==>
;   (*
;    (* PARSE-FLOAT::SIGN
;       (+ (COERCE PARSE-FLOAT::INTEGER-PART TYPE)
;          (* (COERCE PARSE-FLOAT::DECIMAL-PART TYPE) (EXPT # #))))
;    (EXPT 10 (COERCE PARSE-FLOAT::EXPONENT-PART TYPE)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/fn/64871b26712de944ff79e1f58b0e7f4952044810/fn-20180224-git/fn.lisp
; in: DEFUN VALID-_-NAME
;     (EVERY #'DIGIT-CHAR-P (SUBSEQ FN::X 1))
; --> BLOCK SB-INT:DX-FLET FLET SB-KERNEL:%MAP LET DO BLOCK LET TAGBODY TAGBODY 
; --> LET FUNCALL 
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C::FUN)
;                   (LOCALLY
;                    (DECLARE (OPTIMIZE (SB-C::INSERT-ARRAY-BOUNDS-CHECKS 0)))
;                    (AREF #:G12 SB-INT:INDEX)))
; 
; note: implementation limitation: couldn't inline expand because expansion refers to the optimized away object #<SB-C::CTRAN 1 {10048D38A3}>.

; --> BLOCK SB-INT:DX-FLET FLET SB-KERNEL:%MAP LET DO BLOCK LET TAGBODY TAGBODY 
; --> LET FUNCALL SB-C::%FUNCALL BLOCK 
; ==>
;   (LET ((#:VAL3 (FUNCALL #'DIGIT-CHAR-P #:G0)))
;     (UNLESS #:VAL3 (RETURN-FROM #:BLOCK1 NIL)))
; 
; note: deleting unused function
;   (LET ((#:VAL3 (FUNCALL (FUNCTION DIGIT-CHAR-P) #:G0))))

; --> BLOCK SB-INT:DX-FLET FLET SB-KERNEL:%MAP LET DO BLOCK LET TAGBODY TAGBODY 
; --> LET FUNCALL 
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN SB-C::FUN)
;                   (LOCALLY
;                    (DECLARE (OPTIMIZE (SB-C::INSERT-ARRAY-BOUNDS-CHECKS 0)))
;                    (AREF #:G12 SB-INT:INDEX)))
; 
; note: deleting unused function
;   (SB-C::LOCAL-INLINE (FLET "WRAPPER2" :IN VALID-_-NAME))

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/varjo/b6fadbeed4501faf996aaa2e7b9d813deba03ab2/varjo-release-quicklisp-4ecc883f-git/src/vari.cl/special-operators/swizzle.lisp
; in: DEFUN EXTRACT-SWIZZLE-STRING
;     (ASSERT
;      (AND
;       (EVERY (LAMBDA (VARI.CL::_) (FIND VARI.CL::_ VARI.CL::ALLOWED))
;              VARI.CL::COMPONENTS)
;       (>= VARI.CL::NEW-LEN 1) (<= VARI.CL::NEW-LEN 4))
;      NIL (ERROR "Varjo: swizzle form invalid: ~a" VARI.CL::COMPONENTS))
; --> TAGBODY LET 
; ==>
;   (SB-KERNEL:ASSERT-ERROR
;    '(AND
;      (EVERY (LAMBDA (VARI.CL::_) (FIND VARI.CL::_ VARI.CL::ALLOWED))
;             VARI.CL::COMPONENTS)
;      (>= VARI.CL::NEW-LEN 1) (<= VARI.CL::NEW-LEN 4))
;    (LIST) 'NIL (ERROR "Varjo: swizzle form invalid: ~a" VARI.CL::COMPONENTS))
; 
; note: The fourth argument never returns a value.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/varjo/b6fadbeed4501faf996aaa2e7b9d813deba03ab2/varjo-release-quicklisp-4ecc883f-git/src/varjo.internals/test-compile.lisp
; in: DEFUN RAISE-TEST-TRANSLATE-ERROR
;     (ALEXANDRIA.0.DEV:COMPOSE #'PRINC-TO-STRING #'FIRST)
; --> LET LAMBDA FUNCTION FUNCALL 
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN #:COMPOSE14)
;                   (APPLY #:COMPOSE15 ALEXANDRIA.0.DEV::ARGUMENTS))
; 
; note: unable to optimize due to type uncertainty: The first argument is a T, not a NUMBER.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/utils.lisp
; in: DEFN GL-ENUM
;     (THE (UNSIGNED-BYTE 32)
;          (CFFI:FOREIGN-ENUM-VALUE 'CL-OPENGL-BINDINGS:ENUM CEPL-UTILS:KWD))
; 
; note: type assertion too complex to check:
; (VALUES (UNSIGNED-BYTE 32) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/types/cepl-types.lisp
; in: DEFN PRIMITIVE-VERT-LENGTH
;     (THE (UNSIGNED-BYTE 8) (VARJO.INTERNALS:VERTEX-COUNT %CEPL.TYPES::PRIM))
; 
; note: type assertion too complex to check:
; (VALUES (UNSIGNED-BYTE 8) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/types/cepl-types.lisp
; in: DEFN-INLINE BUFFER-STREAM-START
;     (CEPL.DEFN:DEFN-INLINE %CEPL.TYPES:BUFFER-STREAM-START
;         ((STREAM %CEPL.TYPES:BUFFER-STREAM))
;         (UNSIGNED-BYTE 64)
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1) (COMPILATION-SPEED 0))
;                (CEPL.BUILD:PROFILE T))
;       (%CEPL.TYPES::BUFFER-STREAM-%START STREAM))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA %CEPL.TYPES:BUFFER-STREAM-START
;         (STREAM)
;       (DECLARE (TYPE %CEPL.TYPES:BUFFER-STREAM STREAM))
;       (DECLARE (INLINE %CEPL.TYPES:BUFFER-STREAM-START)
;                (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1) (COMPILATION-SPEED 0)))
;       (BLOCK %CEPL.TYPES:BUFFER-STREAM-START
;         (%CEPL.TYPES::BUFFER-STREAM-%START STREAM)))
; 
; note: doing unsigned word to integer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN REGISTER-GPU-BUFFER
;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-GPU-BUFFERS CEPL.CONTEXT::ID)
;             %CEPL.TYPES:GPU-BUFFER)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE %CEPL.TYPES:GPU-BUFFER SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR GPU-BUFFER), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN REGISTER-TEXTURE
;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-TEXTURES CEPL.CONTEXT::ID)
;             GLSL-SYMBOLS.FUNCTIONS:TEXTURE)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE GLSL-SYMBOLS.FUNCTIONS:TEXTURE
;                                         SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR TEXTURE), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN REGISTER-FBO
;     (SETF (AREF CEPL.CONTEXT::FBOS CEPL.CONTEXT::ID) %CEPL.TYPES:FBO)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE %CEPL.TYPES:FBO SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR FBO), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN FORGET-GPU-BUFFER
;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-GPU-BUFFERS
;                 (%CEPL.TYPES:GPU-BUFFER-ID %CEPL.TYPES:GPU-BUFFER))
;             %CEPL.TYPES:+NULL-GPU-BUFFER+)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE %CEPL.TYPES:GPU-BUFFER SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR GPU-BUFFER), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN FORGET-TEXTURE
;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-TEXTURES
;                 (%CEPL.TYPES:TEXTURE-ID GLSL-SYMBOLS.FUNCTIONS:TEXTURE))
;             %CEPL.TYPES:+NULL-TEXTURE+)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE GLSL-SYMBOLS.FUNCTIONS:TEXTURE
;                                         SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR TEXTURE), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN FORGET-FBO
;     (SETF (AREF CEPL.CONTEXT::FBOS (%CEPL.TYPES:%FBO-ID %CEPL.TYPES:FBO))
;             %CEPL.TYPES:+NULL-FBO+)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE %CEPL.TYPES:FBO SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR FBO), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN UBO-BIND-BUFFER-ID-RANGE
;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-UBO-BINDINGS-BUFFER-IDS
;                 CEPL.CONTEXT::UBO-BINDING-POINT)
;             CEPL.CONTEXT::ID)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE (UNSIGNED-BYTE 32) SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 32)), not a SIMPLE-ARRAY.

;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-UBO-BINDING-RANGES
;                 (- CEPL.CONTEXT::RANGE-INDEX 1))
;             CEPL.CONTEXT::OFFSET)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE (UNSIGNED-BYTE 32) SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 32)), not a SIMPLE-ARRAY.

;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-UBO-BINDING-RANGES
;                 CEPL.CONTEXT::RANGE-INDEX)
;             CEPL.CONTEXT::SIZE)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE (UNSIGNED-BYTE 32) SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 32)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN SSBO-BIND-BUFFER-ID-RANGE
;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-SSBO-BINDINGS-BUFFER-IDS
;                 CEPL.CONTEXT::SSBO-BINDING-POINT)
;             CEPL.CONTEXT::ID)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE (UNSIGNED-BYTE 32) SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 32)), not a SIMPLE-ARRAY.

;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-SSBO-BINDING-RANGES
;                 (- CEPL.CONTEXT::RANGE-INDEX 1))
;             CEPL.CONTEXT::OFFSET)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE (UNSIGNED-BYTE 32) SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 32)), not a SIMPLE-ARRAY.

;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-SSBO-BINDING-RANGES
;                 CEPL.CONTEXT::RANGE-INDEX)
;             CEPL.CONTEXT::SIZE)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE (UNSIGNED-BYTE 32) SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 32)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/context/cepl-context.lisp
; in: DEFN TRANSFORM-FEEDBACK-BIND-BUFFER-ID-RANGE
;     (SETF (AREF CEPL.CONTEXT::ARRAY-OF-TRANSFORM-FEEDBACK-BINDINGS-BUFFER-IDS
;                 CEPL.CONTEXT::TFB-BINDING-POINT)
;             CEPL.CONTEXT::ID)
; --> LET* FUNCALL SB-C::%FUNCALL (SETF AREF) 
; --> SB-KERNEL:HAIRY-DATA-VECTOR-SET/CHECK-BOUNDS TRULY-THE 
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-SET ARRAY
;                                    (SB-KERNEL:CHECK-BOUND ARRAY
;                                                           (ARRAY-DIMENSION
;                                                            ARRAY 0)
;                                                           SB-INT:INDEX)
;                                    (THE (UNSIGNED-BYTE 32) SB-C::NEW-VALUE))
; 
; note: unable to avoid runtime dispatch on array element type due to type uncertainty: The first argument is a (VECTOR (UNSIGNED-BYTE 32)), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/stencil/stencil.lisp
; in: DEFN-INLINE STENCIL-PARAMS-TEST
;     (CEPL.DEFN:DEFN-INLINE CEPL.STENCIL:STENCIL-PARAMS-TEST
;         ((CEPL.STENCIL::PARAMS %CEPL.TYPES:STENCIL-PARAMS))
;         FUNCTION
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (CEPL.STENCIL::STENCIL-TEST-ENUM-TO-FUNC
;        (%CEPL.TYPES:%STENCIL-PARAMS-TEST CEPL.STENCIL::PARAMS)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.STENCIL:STENCIL-PARAMS-TEST
;         (CEPL.STENCIL::PARAMS)
;       (DECLARE (TYPE %CEPL.TYPES:STENCIL-PARAMS CEPL.STENCIL::PARAMS))
;       (DECLARE (INLINE CEPL.STENCIL:STENCIL-PARAMS-TEST)
;                (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (BLOCK CEPL.STENCIL:STENCIL-PARAMS-TEST
;         (CEPL.STENCIL::STENCIL-TEST-ENUM-TO-FUNC
;          (%CEPL.TYPES:%STENCIL-PARAMS-TEST CEPL.STENCIL::PARAMS))))
; 
; note: type assertion too complex to check:
; (VALUES FUNCTION &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/stencil/stencil.lisp
; in: DEFN-INLINE STENCIL-PARAMS-ON-STENCIL-TEST-FAIL
;     (CEPL.DEFN:DEFN-INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-TEST-FAIL
;         ((CEPL.STENCIL::PARAMS %CEPL.TYPES:STENCIL-PARAMS))
;         FUNCTION
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;        (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-TEST-FAIL CEPL.STENCIL::PARAMS)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-TEST-FAIL
;         (CEPL.STENCIL::PARAMS)
;       (DECLARE (TYPE %CEPL.TYPES:STENCIL-PARAMS CEPL.STENCIL::PARAMS))
;       (DECLARE (INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-TEST-FAIL)
;                (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (BLOCK CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-TEST-FAIL
;         (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;          (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-TEST-FAIL
;           CEPL.STENCIL::PARAMS))))
; 
; note: type assertion too complex to check:
; (VALUES FUNCTION &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/stencil/stencil.lisp
; in: DEFN-INLINE STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;     (CEPL.DEFN:DEFN-INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;         ((CEPL.STENCIL::PARAMS %CEPL.TYPES:STENCIL-PARAMS))
;         FUNCTION
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;        (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;         CEPL.STENCIL::PARAMS)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;         (CEPL.STENCIL::PARAMS)
;       (DECLARE (TYPE %CEPL.TYPES:STENCIL-PARAMS CEPL.STENCIL::PARAMS))
;       (DECLARE
;        (INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL)
;        (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (BLOCK CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;         (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;          (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;           CEPL.STENCIL::PARAMS))))
; 
; note: type assertion too complex to check:
; (VALUES FUNCTION &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/stencil/stencil.lisp
; in: DEFN-INLINE STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;     (CEPL.DEFN:DEFN-INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;         ((CEPL.STENCIL::PARAMS %CEPL.TYPES:STENCIL-PARAMS))
;         FUNCTION
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;        (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;         CEPL.STENCIL::PARAMS)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;         (CEPL.STENCIL::PARAMS)
;       (DECLARE (TYPE %CEPL.TYPES:STENCIL-PARAMS CEPL.STENCIL::PARAMS))
;       (DECLARE
;        (INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS)
;        (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (BLOCK CEPL.STENCIL:STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;         (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;          (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;           CEPL.STENCIL::PARAMS))))
; 
; note: type assertion too complex to check:
; (VALUES FUNCTION &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/stencil/stencil.lisp
; in: DEFN-INLINE STENCIL-PARAMS-ON-SFAIL
;     (CEPL.DEFN:DEFN-INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-SFAIL
;         ((CEPL.STENCIL::PARAMS %CEPL.TYPES:STENCIL-PARAMS))
;         FUNCTION
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;        (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-TEST-FAIL CEPL.STENCIL::PARAMS)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.STENCIL:STENCIL-PARAMS-ON-SFAIL
;         (CEPL.STENCIL::PARAMS)
;       (DECLARE (TYPE %CEPL.TYPES:STENCIL-PARAMS CEPL.STENCIL::PARAMS))
;       (DECLARE (INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-SFAIL)
;                (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (BLOCK CEPL.STENCIL:STENCIL-PARAMS-ON-SFAIL
;         (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;          (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-TEST-FAIL
;           CEPL.STENCIL::PARAMS))))
; 
; note: type assertion too complex to check:
; (VALUES FUNCTION &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/stencil/stencil.lisp
; in: DEFN-INLINE STENCIL-PARAMS-ON-DPFAIL
;     (CEPL.DEFN:DEFN-INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-DPFAIL
;         ((CEPL.STENCIL::PARAMS %CEPL.TYPES:STENCIL-PARAMS))
;         FUNCTION
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;        (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;         CEPL.STENCIL::PARAMS)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.STENCIL:STENCIL-PARAMS-ON-DPFAIL
;         (CEPL.STENCIL::PARAMS)
;       (DECLARE (TYPE %CEPL.TYPES:STENCIL-PARAMS CEPL.STENCIL::PARAMS))
;       (DECLARE (INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-DPFAIL)
;                (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (BLOCK CEPL.STENCIL:STENCIL-PARAMS-ON-DPFAIL
;         (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;          (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-FAIL
;           CEPL.STENCIL::PARAMS))))
; 
; note: type assertion too complex to check:
; (VALUES FUNCTION &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/stencil/stencil.lisp
; in: DEFN-INLINE STENCIL-PARAMS-ON-DPPASS
;     (CEPL.DEFN:DEFN-INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-DPPASS
;         ((CEPL.STENCIL::PARAMS %CEPL.TYPES:STENCIL-PARAMS))
;         FUNCTION
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;        (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;         CEPL.STENCIL::PARAMS)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.STENCIL:STENCIL-PARAMS-ON-DPPASS
;         (CEPL.STENCIL::PARAMS)
;       (DECLARE (TYPE %CEPL.TYPES:STENCIL-PARAMS CEPL.STENCIL::PARAMS))
;       (DECLARE (INLINE CEPL.STENCIL:STENCIL-PARAMS-ON-DPPASS)
;                (OPTIMIZE (SPEED 3) (SAFETY 1) (DEBUG 1)))
;       (BLOCK CEPL.STENCIL:STENCIL-PARAMS-ON-DPPASS
;         (CEPL.STENCIL::STENCIL-OPERATION-ENUM-TO-FUNC
;          (%CEPL.TYPES:%STENCIL-PARAMS-ON-STENCIL-PASS-DEPTH-TEST-PASS
;           CEPL.STENCIL::PARAMS))))
; 
; note: type assertion too complex to check:
; (VALUES FUNCTION &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/viewports/viewport.lisp
; in: DEFN (SETF VIEWPORT-ORIGIN)
;     (AREF CEPL.VIEWPORTS::VALUE 0)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (FLOOR (AREF CEPL.VIEWPORTS::VALUE 0))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a SINGLE-FLOAT.

;     (AREF CEPL.VIEWPORTS::VALUE 1)
; ==>
;   (SB-KERNEL:HAIRY-DATA-VECTOR-REF/CHECK-BOUNDS ARRAY SB-INT:INDEX)
; 
; note: unable to optimize because: Upgraded element type of array is not known at compile time.

;     (FLOOR (AREF CEPL.VIEWPORTS::VALUE 1))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET 
; ==>
;   (SB-KERNEL:%UNARY-TRUNCATE SB-C::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a SINGLE-FLOAT.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF 
; --> ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR SINGLE-FLOAT (INTEGER 0 0)), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF 
; --> MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FLOAT.

;     (FLOOR (AREF CEPL.VIEWPORTS::VALUE 0))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF NOT IF 
; --> ZEROP 
; ==>
;   (= REM 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR SINGLE-FLOAT (INTEGER 0 0)), not a FLOAT.
; 
; note: unable to open code because: The operands might not be the same type.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF 
; --> MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FLOAT.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES LOCALLY 
; ==>
;   (- SB-C::X SB-C::RES)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR SINGLE-FLOAT (INTEGER 0 0)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR SINGLE-FLOAT (INTEGER 0 0)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF 
; --> MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FIXNUM.
;       etc.

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

;     (FLOOR (AREF CEPL.VIEWPORTS::VALUE 1))
; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL TRUNCATE LET VALUES LOCALLY 
; ==>
;   (- SB-C::X SB-C::RES)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR SINGLE-FLOAT (INTEGER 0 0)) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline (signed-byte 64) arithmetic (cost 5) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a (SIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (SIGNED-BYTE 64).
;       The result is a (VALUES (OR SINGLE-FLOAT (INTEGER 0 0)) &OPTIONAL), not a (VALUES (SIGNED-BYTE 64) &REST T).
;       etc.

; --> FLOOR MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL FUNCTION IF AND IF IF 
; --> MINUSP 
; ==>
;   (< NUMBER 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a (OR (UNSIGNED-BYTE 32) SINGLE-FLOAT), not a FIXNUM.
;       etc.

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

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/types/cffi-helpers.lisp
; in: MAKE-TYPED-FROM-FOREIGN
;     (CEPL.TYPES::MAKE-TYPED-FROM-FOREIGN)
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.TYPES.FOREIGN::DOUBLE-FROM-FOREIGN
;         (CEPL.TYPES::PTR)
;       (DECLARE (TYPE CFFI-SYS:FOREIGN-POINTER CEPL.TYPES::PTR)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 0)))
;       (BLOCK CEPL.TYPES.FOREIGN::DOUBLE-FROM-FOREIGN
;         (CFFI:MEM-AREF CEPL.TYPES::PTR :DOUBLE)))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFN-INLINE PTR-INDEX-1D
;     (CEPL.DEFN:DEFN-INLINE CEPL.C-ARRAYS::PTR-INDEX-1D
;         ((%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;          (CEPL.C-ARRAYS::X %CEPL.TYPES:C-ARRAY-INDEX))
;         CFFI-SYS:FOREIGN-POINTER
;       (DECLARE (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1))
;                (CEPL.BUILD:PROFILE T))
;       (THE CFFI-SYS:FOREIGN-POINTER
;            (CFFI-SYS:INC-POINTER
;             (%CEPL.TYPES:C-ARRAY-POINTER %CEPL.TYPES:C-ARRAY)
;             (THE %CEPL.TYPES:C-ARRAY-INDEX (* # CEPL.C-ARRAYS::X)))))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS::PTR-INDEX-1D
;         (%CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X)
;       (DECLARE (TYPE %CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (TYPE %CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X))
;       (DECLARE (INLINE CEPL.C-ARRAYS::PTR-INDEX-1D)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1)))
;       (BLOCK CEPL.C-ARRAYS::PTR-INDEX-1D
;         (THE CFFI-SYS:FOREIGN-POINTER
;              (CFFI-SYS:INC-POINTER
;               (%CEPL.TYPES:C-ARRAY-POINTER %CEPL.TYPES:C-ARRAY)
;               (THE %CEPL.TYPES:C-ARRAY-INDEX #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN PTR-INDEX-2D
;     (DEFUN CEPL.C-ARRAYS::PTR-INDEX-2D
;            (%CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y)
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Y)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1))
;                (INLINE CFFI-SYS:INC-POINTER %CEPL.TYPES:C-ARRAY-POINTER))
;       (THE CFFI-SYS:FOREIGN-POINTER
;            (CFFI-SYS:INC-POINTER
;             (%CEPL.TYPES:C-ARRAY-POINTER %CEPL.TYPES:C-ARRAY)
;             (THE %CEPL.TYPES:C-ARRAY-INDEX (+ # #)))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS::PTR-INDEX-2D
;         (%CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y)
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Y)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1))
;                (INLINE CFFI-SYS:INC-POINTER %CEPL.TYPES:C-ARRAY-POINTER))
;       (BLOCK CEPL.C-ARRAYS::PTR-INDEX-2D
;         (THE CFFI-SYS:FOREIGN-POINTER
;              (CFFI-SYS:INC-POINTER
;               (%CEPL.TYPES:C-ARRAY-POINTER %CEPL.TYPES:C-ARRAY)
;               (THE %CEPL.TYPES:C-ARRAY-INDEX #)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN PTR-INDEX-3D
;     (DEFUN CEPL.C-ARRAYS::PTR-INDEX-3D
;            (%CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y
;             CEPL.C-ARRAYS::Z)
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Y)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Z)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1)))
;       (LET* ((CEPL.C-ARRAYS::ROW-SIZE (THE %CEPL.TYPES:C-ARRAY-INDEX #))
;              (CEPL.C-ARRAYS::2D-SIZE (THE %CEPL.TYPES:C-ARRAY-INDEX #))
;              (CEPL.C-ARRAYS::BYTE-OFFSET (THE %CEPL.TYPES:C-ARRAY-INDEX #)))
;         (THE CFFI-SYS:FOREIGN-POINTER
;              (CFFI-SYS:INC-POINTER
;               (%CEPL.TYPES:C-ARRAY-POINTER %CEPL.TYPES:C-ARRAY)
;               CEPL.C-ARRAYS::BYTE-OFFSET))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS::PTR-INDEX-3D
;         (%CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Y)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Z)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1)))
;       (BLOCK CEPL.C-ARRAYS::PTR-INDEX-3D
;         (LET* ((CEPL.C-ARRAYS::ROW-SIZE #)
;                (CEPL.C-ARRAYS::2D-SIZE #)
;                (CEPL.C-ARRAYS::BYTE-OFFSET #))
;           (THE CFFI-SYS:FOREIGN-POINTER
;                (CFFI-SYS:INC-POINTER # CEPL.C-ARRAYS::BYTE-OFFSET)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN PTR-INDEX-4D
;     (DEFUN CEPL.C-ARRAYS::PTR-INDEX-4D
;            (%CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y
;             CEPL.C-ARRAYS::Z CEPL.C-ARRAYS::W)
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Y)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Z)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::W)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1)))
;       (LET* ((CEPL.C-ARRAYS::ROW-SIZE (THE %CEPL.TYPES:C-ARRAY-INDEX #))
;              (CEPL.MEASUREMENTS:DIMENSIONS
;               (%CEPL.TYPES:C-ARRAY-DIMENSIONS %CEPL.TYPES:C-ARRAY))
;              (CEPL.C-ARRAYS::2D-SIZE (THE %CEPL.TYPES:C-ARRAY-INDEX #))
;              (CEPL.C-ARRAYS::3D-SIZE (THE %CEPL.TYPES:C-ARRAY-INDEX #))
;              (CEPL.C-ARRAYS::BYTE-OFFSET (THE %CEPL.TYPES:C-ARRAY-INDEX #)))
;         (THE CFFI-SYS:FOREIGN-POINTER
;              (CFFI-SYS:INC-POINTER
;               (%CEPL.TYPES:C-ARRAY-POINTER %CEPL.TYPES:C-ARRAY)
;               CEPL.C-ARRAYS::BYTE-OFFSET))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS::PTR-INDEX-4D
;         (%CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;          CEPL.C-ARRAYS::W)
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Y)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::Z)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::W)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1)))
;       (BLOCK CEPL.C-ARRAYS::PTR-INDEX-4D
;         (LET* ((CEPL.C-ARRAYS::ROW-SIZE #)
;                (CEPL.MEASUREMENTS:DIMENSIONS #)
;                (CEPL.C-ARRAYS::2D-SIZE #)
;                (CEPL.C-ARRAYS::3D-SIZE #)
;                (CEPL.C-ARRAYS::BYTE-OFFSET #))
;           (THE CFFI-SYS:FOREIGN-POINTER
;                (CFFI-SYS:INC-POINTER # CEPL.C-ARRAYS::BYTE-OFFSET)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN PTR-INDEX
;     (DEFUN CEPL.C-ARRAYS:PTR-INDEX
;            (%CEPL.TYPES:C-ARRAY
;             &OPTIONAL (CEPL.C-ARRAYS::X 0)
;             (CEPL.C-ARRAYS::Y 0 CEPL.C-ARRAYS::Y-SET)
;             (CEPL.C-ARRAYS::Z 0 CEPL.C-ARRAYS::Z-SET)
;             (CEPL.C-ARRAYS::W 0 CEPL.C-ARRAYS::W-SET))
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y
;                 CEPL.C-ARRAYS::Z CEPL.C-ARRAYS::W)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1)))
;       (COND
;        (CEPL.C-ARRAYS::W-SET
;         (CEPL.C-ARRAYS::PTR-INDEX-4D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X
;          CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z CEPL.C-ARRAYS::W))
;        (CEPL.C-ARRAYS::Z-SET
;         (CEPL.C-ARRAYS::PTR-INDEX-3D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X
;          CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z))
;        (CEPL.C-ARRAYS::Y-SET
;         (CEPL.C-ARRAYS::PTR-INDEX-2D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X
;          CEPL.C-ARRAYS::Y))
;        (T (CEPL.C-ARRAYS::PTR-INDEX-1D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X))))
; --> PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS:PTR-INDEX
;         (%CEPL.TYPES:C-ARRAY &OPTIONAL (CEPL.C-ARRAYS::X 0)
;          (CEPL.C-ARRAYS::Y 0 CEPL.C-ARRAYS::Y-SET)
;          (CEPL.C-ARRAYS::Z 0 CEPL.C-ARRAYS::Z-SET)
;          (CEPL.C-ARRAYS::W 0 CEPL.C-ARRAYS::W-SET))
;       (DECLARE (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (%CEPL.TYPES:C-ARRAY-INDEX CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y
;                 CEPL.C-ARRAYS::Z CEPL.C-ARRAYS::W)
;                (OPTIMIZE (SPEED 3) (SAFETY 0) (DEBUG 1)))
;       (BLOCK CEPL.C-ARRAYS:PTR-INDEX
;         (COND
;          (CEPL.C-ARRAYS::W-SET
;           (CEPL.C-ARRAYS::PTR-INDEX-4D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X
;            CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z CEPL.C-ARRAYS::W))
;          (CEPL.C-ARRAYS::Z-SET
;           (CEPL.C-ARRAYS::PTR-INDEX-3D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X
;            CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z))
;          (CEPL.C-ARRAYS::Y-SET
;           (CEPL.C-ARRAYS::PTR-INDEX-2D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X
;            CEPL.C-ARRAYS::Y))
;          (T
;           (CEPL.C-ARRAYS::PTR-INDEX-1D %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::X)))))
; 
; note: doing SAP to pointer coercion (cost 20) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN AREF-C*-1D
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN AREF-C*-2D
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN AREF-C*-3D
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN AREF-C*-4D
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN (SETF AREF-C*-1D)
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN (SETF AREF-C*-2D)
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN (SETF AREF-C*-3D)
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/aref-c.lisp
; in: DEFUN (SETF AREF-C*-4D)
;     (FUNCALL CEPL.C-ARRAYS::REF CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::REF)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::VALUE)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN MAP-C
;     (CEPL.DEFN:DEFN CEPL.C-ARRAYS:MAP-C
;         (#'FUNCTION (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY) &OPTIONAL
;          CEPL.C-ARRAYS::DESTINATION-ELEMENT-TYPE)
;         (OR NULL %CEPL.TYPES:C-ARRAY)
;       (LET ((CEPL.C-ARRAYS::R
;              (CEPL.C-ARRAYS:MAKE-C-ARRAY NIL :DIMENSIONS # :ELEMENT-TYPE #)))
;         (CEPL.C-ARRAYS:MAP-C-INTO CEPL.C-ARRAYS::R FUNCTION %CEPL.TYPES:C-ARRAY)))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS:MAP-C
;         (FUNCTION %CEPL.TYPES:C-ARRAY &OPTIONAL
;          (CEPL.C-ARRAYS::DESTINATION-ELEMENT-TYPE NIL))
;       (DECLARE (TYPE FUNCTION FUNCTION)
;                (TYPE %CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY)
;                (TYPE (OR T NULL) CEPL.C-ARRAYS::DESTINATION-ELEMENT-TYPE))
;       (DECLARE)
;       (BLOCK CEPL.C-ARRAYS:MAP-C
;         (LET ((CEPL.C-ARRAYS::R #))
;           (CEPL.C-ARRAYS:MAP-C-INTO CEPL.C-ARRAYS::R FUNCTION
;            %CEPL.TYPES:C-ARRAY))))
; 
; note: type assertion too complex to check:
; (VALUES &OPTIONAL (OR NULL %CEPL.TYPES:C-ARRAY) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN MAP-C-INTO
;     (CEPL.DEFN:DEFN CEPL.C-ARRAYS:MAP-C-INTO
;         ((CEPL.C-ARRAYS::DESTINATION-C-ARRAY %CEPL.TYPES:C-ARRAY) #'FUNCTION
;          (CEPL.C-ARRAYS::SOURCE-C-ARRAY %CEPL.TYPES:C-ARRAY))
;         (OR NULL %CEPL.TYPES:C-ARRAY)
;       (LET ((CEPL.C-ARRAYS::FUNC FUNCTION)
;             (CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::SOURCE-C-ARRAY)
;             (CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::DESTINATION-C-ARRAY))
;         (CEPL-UTILS:ECASE= (CEPL.C-ARRAYS::C-ARRAY-RANK CEPL.C-ARRAYS::SRC)
;           (1
;            (CEPL.C-ARRAYS::%MAP-C-INTO-1D CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::FUNC
;             CEPL.C-ARRAYS::SRC))
;           (2
;            (CEPL.C-ARRAYS::%MAP-C-INTO-2D CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::FUNC
;             CEPL.C-ARRAYS::SRC))
;           (3
;            (CEPL.C-ARRAYS::%MAP-C-INTO-3D CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::FUNC
;             CEPL.C-ARRAYS::SRC))
;           (4
;            (CEPL.C-ARRAYS::%MAP-C-INTO-4D CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::FUNC
;             CEPL.C-ARRAYS::SRC)))))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS:MAP-C-INTO
;         (CEPL.C-ARRAYS::DESTINATION-C-ARRAY FUNCTION
;          CEPL.C-ARRAYS::SOURCE-C-ARRAY)
;       (DECLARE (TYPE %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::DESTINATION-C-ARRAY)
;                (TYPE FUNCTION FUNCTION)
;                (TYPE %CEPL.TYPES:C-ARRAY CEPL.C-ARRAYS::SOURCE-C-ARRAY))
;       (DECLARE)
;       (BLOCK CEPL.C-ARRAYS:MAP-C-INTO
;         (LET ((CEPL.C-ARRAYS::FUNC FUNCTION)
;               (CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::SOURCE-C-ARRAY)
;               (CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::DESTINATION-C-ARRAY))
;           (CEPL-UTILS:ECASE= (CEPL.C-ARRAYS::C-ARRAY-RANK CEPL.C-ARRAYS::SRC)
;             (1 #)
;             (2 #)
;             (3 #)
;             (4 #)))))
; 
; note: type assertion too complex to check:
; (VALUES &OPTIONAL (OR NULL %CEPL.TYPES:C-ARRAY) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %MAP-C-INTO-1D
;     (LOOP :FOR CEPL.C-ARRAYS::I :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                              CEPL.C-ARRAYS::I)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::I :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::I)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::I))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::I :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                              CEPL.C-ARRAYS::I)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::I 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::I :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::I)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::I))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::I 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %MAP-C-INTO-2D
;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                              CEPL.C-ARRAYS::Y)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::X
;                                           CEPL.C-ARRAYS::Y)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::X
;                                                      CEPL.C-ARRAYS::Y))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                              CEPL.C-ARRAYS::Y)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::X 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Y 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::X
;                                           CEPL.C-ARRAYS::Y)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::X
;                                                      CEPL.C-ARRAYS::Y))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::X 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Y 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %MAP-C-INTO-3D
;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                            (CEPL.C-ARRAYS:AREF-C
;                                             CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                             CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y
;                                                        CEPL.C-ARRAYS::Z))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                              CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (SETF # #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y
;                                                     CEPL.C-ARRAYS::Z)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::X
;                                           CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::X
;                                                      CEPL.C-ARRAYS::Y
;                                                      CEPL.C-ARRAYS::Z))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                            (CEPL.C-ARRAYS:AREF-C
;                                             CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                             CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y
;                                                        CEPL.C-ARRAYS::Z))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                              CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::X 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y
;                                                        CEPL.C-ARRAYS::Z))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Y 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                            (CEPL.C-ARRAYS:AREF-C
;                                             CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                             CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Z 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (SETF # #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y
;                                                     CEPL.C-ARRAYS::Z)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::X
;                                           CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::X
;                                                      CEPL.C-ARRAYS::Y
;                                                      CEPL.C-ARRAYS::Z))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::X 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y
;                                                     CEPL.C-ARRAYS::Z)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Y 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (SETF # #))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Z 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %MAP-C-INTO-4D
;     (LOOP :FOR CEPL.C-ARRAYS::W :BELOW (FOURTH CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                                       CEPL.C-ARRAYS::DIM)
;                                         :DO (FUNCALL CEPL.C-ARRAYS::FUNC #)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                            (CEPL.C-ARRAYS:AREF-C
;                                             CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                             CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;                                             CEPL.C-ARRAYS::W)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y
;                                                        CEPL.C-ARRAYS::Z
;                                                        CEPL.C-ARRAYS::W))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                              CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;                                              CEPL.C-ARRAYS::W)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::W :BELOW (FOURTH CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                                       CEPL.C-ARRAYS::DIM)
;                                         :DO (SETF #)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (SETF # #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y
;                                                     CEPL.C-ARRAYS::Z
;                                                     CEPL.C-ARRAYS::W)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::X
;                                           CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;                                           CEPL.C-ARRAYS::W)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::X
;                                                      CEPL.C-ARRAYS::Y
;                                                      CEPL.C-ARRAYS::Z
;                                                      CEPL.C-ARRAYS::W))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET IF = IF 
; ==>
;   (= SB-C::X SB-C::Y)
; 
; note: unable to open code because: The operands might not be the same type.

;     (LOOP :FOR CEPL.C-ARRAYS::W :BELOW (FOURTH CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                                       CEPL.C-ARRAYS::DIM)
;                                         :DO (FUNCALL CEPL.C-ARRAYS::FUNC #)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                            (CEPL.C-ARRAYS:AREF-C
;                                             CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                             CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;                                             CEPL.C-ARRAYS::W)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y
;                                                        CEPL.C-ARRAYS::Z
;                                                        CEPL.C-ARRAYS::W))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                        (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                              CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;                                              CEPL.C-ARRAYS::W)))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::X 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                  (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                        CEPL.C-ARRAYS::X
;                                                        CEPL.C-ARRAYS::Y
;                                                        CEPL.C-ARRAYS::Z
;                                                        CEPL.C-ARRAYS::W))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Y 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (FUNCALL CEPL.C-ARRAYS::FUNC
;                                            (CEPL.C-ARRAYS:AREF-C
;                                             CEPL.C-ARRAYS::SRC CEPL.C-ARRAYS::X
;                                             CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;                                             CEPL.C-ARRAYS::W)))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Z 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::W :BELOW (FOURTH CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                                       CEPL.C-ARRAYS::DIM)
;                                         :DO (FUNCALL CEPL.C-ARRAYS::FUNC #)))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::W 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::W :BELOW (FOURTH CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                                       CEPL.C-ARRAYS::DIM)
;                                         :DO (SETF #)))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (SETF # #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y
;                                                     CEPL.C-ARRAYS::Z
;                                                     CEPL.C-ARRAYS::W)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

;     (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;           :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST CEPL.C-ARRAYS::X
;                                           CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z
;                                           CEPL.C-ARRAYS::W)
;                       (FUNCALL CEPL.C-ARRAYS::FUNC
;                                (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::SRC
;                                                      CEPL.C-ARRAYS::X
;                                                      CEPL.C-ARRAYS::Y
;                                                      CEPL.C-ARRAYS::Z
;                                                      CEPL.C-ARRAYS::W))))
; --> BLOCK LET TAGBODY WHEN IF >= OR LET > IF 
; ==>
;   (> SB-C::X SB-C::Y)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::X 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST CEPL.C-ARRAYS::DIM)
;                     :DO (SETF (CEPL.C-ARRAYS:AREF-C CEPL.C-ARRAYS::DST
;                                                     CEPL.C-ARRAYS::X
;                                                     CEPL.C-ARRAYS::Y
;                                                     CEPL.C-ARRAYS::Z
;                                                     CEPL.C-ARRAYS::W)
;                                 (FUNCALL CEPL.C-ARRAYS::FUNC #))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Y 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (SETF # #))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::Z 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

;     (LOOP :FOR CEPL.C-ARRAYS::W :BELOW (FOURTH CEPL.C-ARRAYS::DIM)
;           :DO (LOOP :FOR CEPL.C-ARRAYS::Z :BELOW (THIRD CEPL.C-ARRAYS::DIM)
;                     :DO (LOOP :FOR CEPL.C-ARRAYS::Y :BELOW (SECOND
;                                                             CEPL.C-ARRAYS::DIM)
;                               :DO (LOOP :FOR CEPL.C-ARRAYS::X :BELOW (FIRST
;                                                                       CEPL.C-ARRAYS::DIM)
;                                         :DO (SETF #)))))
; --> BLOCK LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   (+ CEPL.C-ARRAYS::W 1)
; 
; 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 1) &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 1) &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN ACROSS-C
;     (CEPL.DEFN:DEFN CEPL.C-ARRAYS::ACROSS-C
;         (#'FUNCTION (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY))
;         %CEPL.TYPES:C-ARRAY
;       (CEPL-UTILS:ECASE= (CEPL.C-ARRAYS::C-ARRAY-RANK %CEPL.TYPES:C-ARRAY)
;         (1 (CEPL.C-ARRAYS::%ACROSS-C-1D FUNCTION %CEPL.TYPES:C-ARRAY))
;         (2 (CEPL.C-ARRAYS::%ACROSS-C-2D FUNCTION %CEPL.TYPES:C-ARRAY))
;         (3 (CEPL.C-ARRAYS::%ACROSS-C-3D FUNCTION %CEPL.TYPES:C-ARRAY))
;         (4 (CEPL.C-ARRAYS::%ACROSS-C-4D FUNCTION %CEPL.TYPES:C-ARRAY))))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS::ACROSS-C
;         #'%CEPL.TYPES:C-ARRAY
;       (DECLARE (TYPE FUNCTION FUNCTION)
;                (TYPE %CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY))
;       (DECLARE)
;       (BLOCK CEPL.C-ARRAYS::ACROSS-C
;         (CEPL-UTILS:ECASE= (CEPL.C-ARRAYS::C-ARRAY-RANK %CEPL.TYPES:C-ARRAY)
;           (1 (CEPL.C-ARRAYS::%ACROSS-C-1D FUNCTION %CEPL.TYPES:C-ARRAY))
;           (2 (CEPL.C-ARRAYS::%ACROSS-C-2D FUNCTION %CEPL.TYPES:C-ARRAY))
;           (3 (CEPL.C-ARRAYS::%ACROSS-C-3D FUNCTION %CEPL.TYPES:C-ARRAY))
;           (4 (CEPL.C-ARRAYS::%ACROSS-C-4D FUNCTION %CEPL.TYPES:C-ARRAY)))))
; 
; note: type assertion too complex to check:
; (VALUES %CEPL.TYPES:C-ARRAY &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN ACROSS-C-PTR
;     (CEPL.DEFN:DEFN CEPL.C-ARRAYS:ACROSS-C-PTR
;         (#'FUNCTION (%CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY))
;         %CEPL.TYPES:C-ARRAY
;       (CEPL-UTILS:ECASE= (CEPL.C-ARRAYS::C-ARRAY-RANK %CEPL.TYPES:C-ARRAY)
;         (1 (CEPL.C-ARRAYS::%ACROSS-C-PTR-1D FUNCTION %CEPL.TYPES:C-ARRAY))
;         (2 (CEPL.C-ARRAYS::%ACROSS-C-PTR-2D FUNCTION %CEPL.TYPES:C-ARRAY))
;         (3 (CEPL.C-ARRAYS::%ACROSS-C-PTR-3D FUNCTION %CEPL.TYPES:C-ARRAY))
;         (4 (CEPL.C-ARRAYS::%ACROSS-C-PTR-4D FUNCTION %CEPL.TYPES:C-ARRAY))))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.C-ARRAYS:ACROSS-C-PTR
;         #'%CEPL.TYPES:C-ARRAY
;       (DECLARE (TYPE FUNCTION FUNCTION)
;                (TYPE %CEPL.TYPES:C-ARRAY %CEPL.TYPES:C-ARRAY))
;       (DECLARE)
;       (BLOCK CEPL.C-ARRAYS:ACROSS-C-PTR
;         (CEPL-UTILS:ECASE= (CEPL.C-ARRAYS::C-ARRAY-RANK %CEPL.TYPES:C-ARRAY)
;           (1 (CEPL.C-ARRAYS::%ACROSS-C-PTR-1D FUNCTION %CEPL.TYPES:C-ARRAY))
;           (2 (CEPL.C-ARRAYS::%ACROSS-C-PTR-2D FUNCTION %CEPL.TYPES:C-ARRAY))
;           (3 (CEPL.C-ARRAYS::%ACROSS-C-PTR-3D FUNCTION %CEPL.TYPES:C-ARRAY))
;           (4 (CEPL.C-ARRAYS::%ACROSS-C-PTR-4D FUNCTION %CEPL.TYPES:C-ARRAY)))))
; 
; note: type assertion too complex to check:
; (VALUES %CEPL.TYPES:C-ARRAY &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %ACROSS-C-PTR-1D
;     (FUNCALL CEPL.C-ARRAYS::FUNC CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::FUNC)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %ACROSS-C-PTR-2D
;     (FUNCALL CEPL.C-ARRAYS::FUNC CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X
;              CEPL.C-ARRAYS::Y)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::FUNC)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %ACROSS-C-PTR-3D
;     (FUNCALL CEPL.C-ARRAYS::FUNC CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X
;              CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::FUNC)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y
;                   CEPL.C-ARRAYS::Z)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/map.lisp
; in: DEFN %ACROSS-C-PTR-4D
;     (FUNCALL CEPL.C-ARRAYS::FUNC CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X
;              CEPL.C-ARRAYS::Y CEPL.C-ARRAYS::Z CEPL.C-ARRAYS::W)
; ==>
;   (SB-C::%FUNCALL (SB-KERNEL:%COERCE-CALLABLE-TO-FUN CEPL.C-ARRAYS::FUNC)
;                   CEPL.C-ARRAYS::PTR CEPL.C-ARRAYS::X CEPL.C-ARRAYS::Y
;                   CEPL.C-ARRAYS::Z CEPL.C-ARRAYS::W)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/c-arrays/rest.lisp
; in: DEFN SUBSEQ-C
;     (%CEPL.TYPES:%MAKE-C-ARRAY :POINTER
;                                (CFFI-SYS:INC-POINTER
;                                 (%CEPL.TYPES:C-ARRAY-POINTER ARRAY)
;                                 (* CEPL.C-ARRAYS::ELEM-SIZE
;                                    CEPL.C-ARRAYS::START))
;                                :DIMENSIONS (%CEPL.TYPES:C-ARRAY-DIMENSIONS ARRAY)
;                                :TOTAL-SIZE (%CEPL.TYPES:C-ARRAY-TOTAL-SIZE ARRAY)
;                                :ELEMENT-BYTE-SIZE
;                                (%CEPL.TYPES:C-ARRAY-ELEMENT-BYTE-SIZE ARRAY)
;                                :ELEMENT-TYPE
;                                (%CEPL.TYPES:C-ARRAY-ELEMENT-TYPE ARRAY)
;                                :STRUCT-ELEMENT-TYPEP ...)
; 
; note: doing SAP to pointer coercion (cost 20)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/gpu-arrays/buffer-backed.lisp
; in: DEFN SUBSEQ-G
;     (CEPL.DEFN:DEFN CEPL.GPU-ARRAYS.BUFFER-BACKED:SUBSEQ-G
;         ((ARRAY %CEPL.TYPES:GPU-ARRAY-BB)
;          (CEPL.GPU-ARRAYS.BUFFER-BACKED::START %CEPL.TYPES:C-ARRAY-INDEX)
;          &OPTIONAL (CEPL.GPU-ARRAYS.BUFFER-BACKED::END %CEPL.TYPES:C-ARRAY-INDEX))
;         %CEPL.TYPES:GPU-ARRAY-BB
;       (DECLARE (CEPL.BUILD:PROFILE T))
;       (CEPL.GPU-ARRAYS.BUFFER-BACKED:SUBSEQ-G-RAW ARRAY
;        CEPL.GPU-ARRAYS.BUFFER-BACKED::START CEPL.GPU-ARRAYS.BUFFER-BACKED::END
;        :NEW-ELEMENT-TYPE NIL))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA CEPL.GPU-ARRAYS.BUFFER-BACKED:SUBSEQ-G
;         (ARRAY CEPL.GPU-ARRAYS.BUFFER-BACKED::START &OPTIONAL
;          (CEPL.GPU-ARRAYS.BUFFER-BACKED::END NIL))
;       (DECLARE (TYPE %CEPL.TYPES:GPU-ARRAY-BB ARRAY)
;                (TYPE %CEPL.TYPES:C-ARRAY-INDEX
;                 CEPL.GPU-ARRAYS.BUFFER-BACKED::START)
;                (TYPE (OR %CEPL.TYPES:C-ARRAY-INDEX NULL)
;                 CEPL.GPU-ARRAYS.BUFFER-BACKED::END))
;       (DECLARE)
;       (BLOCK CEPL.GPU-ARRAYS.BUFFER-BACKED:SUBSEQ-G
;         (CEPL.GPU-ARRAYS.BUFFER-BACKED:SUBSEQ-G-RAW ARRAY
;          CEPL.GPU-ARRAYS.BUFFER-BACKED::START
;          CEPL.GPU-ARRAYS.BUFFER-BACKED::END :NEW-ELEMENT-TYPE NIL)))
; 
; note: type assertion too complex to check:
; (VALUES %CEPL.TYPES:GPU-ARRAY-BB &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/vaos/vaos.lisp
; in: DEFN FREE-VAO
;     (CL-OPENGL-BINDINGS:DELETE-VERTEX-ARRAYS 1 CEPL.VAOS::ID)
; 
; note: doing SAP to pointer coercion (cost 20) from #:VAR2

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/vaos/vaos.lisp
; in: DEFN MAKE-VAO
;     (THE %CEPL.TYPES:GL-ID
;          (CEPL.VAOS:MAKE-VAO-FROM-ID
;           (PROGN (ASSERT (AND # #)) (CL-OPENGL:GEN-VERTEX-ARRAY))
;           CEPL.VAOS::GPU-ARRAYS CEPL.VAOS::INDEX-ARRAY))
; 
; note: type assertion too complex to check:
; (VALUES (UNSIGNED-BYTE 32) &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/fbos/fbo.lisp
; in: DEFN ATTACHMENT-VIEWPORT
;     (AREF CEPL.FBOS::ARR %CEPL.TYPES:ATTACHMENT-NAME)
; --> 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 (VECTOR ATT), not a SIMPLE-ARRAY.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/core/queries/query.lisp
; in: DEFN GPU-QUERY-RESULT-AVAILABLE-P
;     (CL-OPENGL-BINDINGS:GET-QUERY-OBJECT-UIV
;      (%CEPL.TYPES:GPU-QUERY-ID CEPL.QUERIES::QUERY) :QUERY-RESULT-AVAILABLE
;      CEPL.QUERIES::CBOOL)
; 
; note: doing SAP to pointer coercion (cost 20) from #:VAR2
Unhandled SIMPLE-ERROR in thread #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>: Can't inherit "FORMATTER" from "DOCUMENTATION-UTILS", it is inherited from "COMMON-LISP"

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<SIMPLE-ERROR "Can't inherit ~S from ~S, it is inherited from ~S" {100D706E33}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<SIMPLE-ERROR "Can't inherit ~S from ~S, it is inherited from ~S" {100D706E33}>)
2: (INVOKE-DEBUGGER #<SIMPLE-ERROR "Can't inherit ~S from ~S, it is inherited from ~S" {100D706E33}>)
3: (ERROR "Can't inherit ~S from ~S, it is inherited from ~S" "FORMATTER" "DOCUMENTATION-UTILS" "COMMON-LISP")
4: (UIOP/PACKAGE::ENSURE-INHERITED "FORMATTER" DOCUMENTATION-UTILS:FORMATTER #<PACKAGE "CEPL.DOCS"> #<PACKAGE "DOCUMENTATION-UTILS"> NIL #<HASH-TABLE :TEST EQUAL :COUNT 0 {100D6BE8D3}> #<HASH-TABLE :TEST EQUAL :COUNT 0 {100D6BECF3}> #<HASH-TABLE :TEST EQUAL :COUNT 1387 {100D6BF533}>)
5: (UIOP/PACKAGE:ENSURE-PACKAGE :CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM NIL :EXPORT (:GEN-DOCS) :INTERN NIL :RECYCLE (:CEPL.DOCS) :MIX NIL :REEXPORT NIL :UNINTERN NIL)
6: (SB-INT:SIMPLE-EVAL-IN-LEXENV (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...))) #<NULL-LEXENV>)
7: (SB-INT:SIMPLE-EVAL-IN-LEXENV (PROGN (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...)))) #<NULL-LEXENV>)
8: (EVAL-TLF (PROGN (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...)))) 0 #<NULL-LEXENV>)
9: ((FLET SB-C::FROB :IN SB-C::EVAL-COMPILE-TOPLEVEL))
10: ((FLET SB-C::DEFAULT-PROCESSOR :IN SB-C::PROCESS-TOPLEVEL-FORM) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...))))
11: (SB-C::PROCESS-TOPLEVEL-FORM (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...))) (#1=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE # :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...)))) (PROGN #1#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
12: (SB-C::PROCESS-TOPLEVEL-PROGN ((APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...)))) (#1=(EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE # :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...)))) (PROGN #1#) SB-C::ORIGINAL-SOURCE-START 0 0) (:COMPILE-TOPLEVEL))
13: (SB-C::PROCESS-TOPLEVEL-FORM (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE (:CL :CEPL :DOCUMENTATION-UTILS) :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...)))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #)))) SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
14: (SB-C::PROCESS-TOPLEVEL-PROGN ((EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE # :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...))))) ((PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE #)))) SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
15: (SB-C::PROCESS-TOPLEVEL-FORM (PROGN (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE) (APPLY (QUOTE UIOP/PACKAGE:ENSURE-PACKAGE) (QUOTE (:CEPL.DOCS :NICKNAMES NIL :DOCUMENTATION NIL :USE # :SHADOW NIL :SHADOWING-IMPORT-FROM NIL :IMPORT-FROM ...))))) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
16: ((FLET SB-C::DEFAULT-PROCESSOR :IN SB-C::PROCESS-TOPLEVEL-FORM) (UIOP/PACKAGE:DEFINE-PACKAGE :CEPL.DOCS (:USE :CL :CEPL :DOCUMENTATION-UTILS) (:EXPORT :GEN-DOCS)))
17: (SB-C::PROCESS-TOPLEVEL-FORM (UIOP/PACKAGE:DEFINE-PACKAGE :CEPL.DOCS (:USE :CL :CEPL :DOCUMENTATION-UTILS) (:EXPORT :GEN-DOCS)) (SB-C::ORIGINAL-SOURCE-START 0 0) NIL)
18: ((LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-SUB-COMPILE-FILE) (UIOP/PACKAGE:DEFINE-PACKAGE :CEPL.DOCS (:USE :CL :CEPL :DOCUMENTATION-UTILS) (:EXPORT :GEN-DOCS)) :CURRENT-INDEX 0)
19: (SB-C::%DO-FORMS-FROM-INFO #<FUNCTION (LAMBDA (SB-KERNEL:FORM &KEY :CURRENT-INDEX &ALLOW-OTHER-KEYS) :IN SB-C::SUB-SUB-COMPILE-FILE) {22248C2B}> #<SB-C::SOURCE-INFO {100D6B3653}> SB-C::INPUT-ERROR-IN-COMPILE-FILE)
20: (SB-C::SUB-SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {100D6B3653}>)
21: ((FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::SUB-COMPILE-FILE))
22: ((FLET "WITHOUT-INTERRUPTS-BODY-29" :IN SB-THREAD::CALL-WITH-RECURSIVE-LOCK))
23: (SB-THREAD::CALL-WITH-RECURSIVE-LOCK #<CLOSURE (FLET SB-THREAD::WITH-RECURSIVE-LOCK-THUNK :IN SB-C::SUB-COMPILE-FILE) {7FFFF6DA66DB}> #<SB-THREAD:MUTEX "World Lock" owner: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>> T NIL)
24: ((LAMBDA NIL :IN SB-C::SUB-COMPILE-FILE))
25: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
26: (SB-C::SUB-COMPILE-FILE #<SB-C::SOURCE-INFO {100D6B3653}>)
27: (COMPILE-FILE #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/docs/api/package.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (224)) /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/docs/api/... {100D758E5F}> :VERBOSE NIL :PRINT NIL :EXTERNAL-FORMAT :UTF-8 :TRACE-FILE NIL :BLOCK-COMPILE NIL :EMIT-CFASL NIL)
28: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<CLOSURE (LAMBDA NIL :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100D6B0A0B}> NIL)
29: (UIOP/PATHNAME:CALL-WITH-ENOUGH-PATHNAME #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/docs/api/package.lisp" NIL #<CLOSURE (LAMBDA (UIOP/LISP-BUILD::INPUT-FILE) :IN UIOP/LISP-BUILD:COMPILE-FILE*) {100D6B020B}>)
30: (UIOP/LISP-BUILD:COMPILE-FILE* #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/docs/api/package.lisp" :OUTPUT-FILE #P#<(SIMPLE-ARRAY CHARACTER (212)) /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/cepl/4b1bbc5e091be5dc54f9eaf0dee7574c8f77384a/cepl-release-quicklisp-b10a3716-git/docs/api/... {100D764D6F}> :EXTERNAL-FORMAT :UTF-8 :WARNINGS-FILE NIL)
31: (ASDF/LISP-ACTION:PERFORM-LISP-COMPILATION #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cepl" "docs/api/package">)
32: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cepl" "docs/api/package">)
33: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
34: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "cepl" "docs/api/package">) [fast-method]
35: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005913423}>) [fast-method]
36: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
37: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005913423}>) [fast-method]
38: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cepl.camera"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
39: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cepl.camera">)
40: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
41: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "cepl.camera">) [fast-method]
42: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "cepl.camera")
43: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
44: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cepl.camera") [fast-method]
45: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {100590DB7B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
46: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
47: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {10058CAF4B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
48: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "cepl.camera") [fast-method]
49: (DEPCHECK::COMPUTE-DEPENDENCIES "cepl.camera" "cepl.camera")
50: (DEPCHECK::MAGIC "cepl.camera" "cepl.camera" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-vSn1Oxns/depcheck-win.txt")
51: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "cepl.camera" "cepl.camera" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-vSn1Oxns/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-vSn1Oxns/depcheck-fail.txt"))
52: ((LAMBDA NIL :IN "/home/quicklisp/src/quicklisp-controller/dumper-2SKVI5f7.lisp"))
53: ((FLET SB-UNIX::BODY :IN SAVE-LISP-AND-DIE))
54: ((FLET "WITHOUT-INTERRUPTS-BODY-36" :IN SAVE-LISP-AND-DIE))
55: ((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
;   printed 155 notes