matlisp

SBCL 1.4.4 / ASDF 3.3.1

matlisp-tests

WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/matlisp.asd" contains definition for system "matlisp-tests". Please only define "matlisp" and secondary systems with a name starting with "matlisp/" (e.g. "matlisp/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/matlisp.asd" contains definition for system "matlisp-tests". Please only define "matlisp" and secondary systems with a name starting with "matlisp/" (e.g. "matlisp/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/matlisp.asd" contains definition for system "matlisp-tests". Please only define "matlisp" and secondary systems with a name starting with "matlisp/" (e.g. "matlisp/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/cl-ppcre/3d57f1e446e4894097acebf36d52978ddaa62531/cl-ppcre-20180225-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/parse-float/c280e2e4f7fd153d0ddec5de03f56b0891f33e24/parse-float-20180225-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.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/ieee-floats/fa9e496f0fcf4ba05754fc32787f728ca6e2d674/ieee-floats-20180225-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/trivial-garbage/8edc182c56fc03da3a83f6fb26d446c6f381abec/trivial-garbage-20180225-git/trivial-garbage.asd" contains definition for system "trivial-garbage-tests". Please only define "trivial-garbage" and secondary systems with a name starting with "trivial-garbage/" (e.g. "trivial-garbage/test") in that file.
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/external-program/6f4681afcad4f7c061ff1a96dda141b8a667dfc8/external-program-20180225-git/external-program.asd" contains definition for system "external-program-test". Please only define "external-program" and secondary systems with a name starting with "external-program/" (e.g. "external-program/test") in that file.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/string.lisp
; in: DEFUN SPLIT-SEQ
;     (>= MATLISP-UTILITIES::SPLIT-COUNT MATLISP-UTILITIES::MAX-CUTS)
; ==>
;   MATLISP-UTILITIES::SPLIT-COUNT
; 
; note: deleting unreachable code

;     (MATLISP-UTILITIES::LEFT-SPLIT MATLISP-UTILITIES::PREV
;      (1+ MATLISP-UTILITIES::I))
; ==>
;   MATLISP-UTILITIES::PREV
; 
; note: deleting unreachable code

;     (MATLISP-UTILITIES::LEFT-SPLIT MATLISP-UTILITIES::PREV MATLISP-UTILITIES::I)
; ==>
;   MATLISP-UTILITIES::PREV
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (PUSH (STRING (AREF MATLISP-UTILITIES::SEQ MATLISP-UTILITIES::I))
;           MATLISP-UTILITIES::SPLIT-LIST)
; --> LET* SETQ THE CONS 
; ==>
;   MATLISP-UTILITIES::SPLIT-LIST
; 
; note: deleting unreachable code

;     (INCF MATLISP-UTILITIES::SPLIT-COUNT)
; --> SETQ THE + 
; ==>
;   MATLISP-UTILITIES::SPLIT-COUNT
; 
; note: deleting unreachable code

;     (PUSH MATLISP-UTILITIES::I MATLISP-UTILITIES::DELETES)
; --> LET* 
; ==>
;   MATLISP-UTILITIES::I
; 
; note: deleting unreachable code

; --> LET* SETQ THE CONS 
; ==>
;   MATLISP-UTILITIES::DELETES
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/macros.lisp
; in: DEFMACRO WITH-MEMOIZATION
;     (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::BODY
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST 'LET MATLISP-UTILITIES::BINDINGS &BODY
;          (OR # MATLISP-UTILITIES::BODY) &AUX (MATLISP-UTILITIES::DECLARES #)
;          (MATLISP-UTILITIES::ID #)))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        `(LET (,@MATLISP-UTILITIES::BINDINGS)
;           ,@MATLISP-UTILITIES::DECLARES
;           (VALUES-LIST
;            (MATLISP-UTILITIES:GETHASH! # ,MATLISP-UTILITIES::TABLE #))))
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST (AND MATLISP-UTILITIES::DEF #)
;          MATLISP-UTILITIES::NAME MATLISP-UTILITIES::FUNC-ARGS &BODY
;          (OR # MATLISP-UTILITIES::BODY) &AUX (MATLISP-UTILITIES::DECLARES #)
;          (MATLISP-UTILITIES::ID #)))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        (ASSERT (NOT (INTERSECTION '# MATLISP-UTILITIES::FUNC-ARGS)) NIL
;                "can't memoize functions with &rest, &allow-other-keys in their defining lambda-lists")
;        `(,MATLISP-UTILITIES::DEF ,MATLISP-UTILITIES::NAME
;          (,@MATLISP-UTILITIES::FUNC-ARGS) ,@MATLISP-UTILITIES::DECLARES
;          (VALUES-LIST
;           (MATLISP-UTILITIES:GETHASH! # ,MATLISP-UTILITIES::TABLE #))))
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST (AND MATLISP-UTILITIES::DEF #)
;          MATLISP-UTILITIES::DEFINITIONS &BODY MATLISP-UTILITIES::BODY))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        `(,MATLISP-UTILITIES::DEF (,@(MAPCAR #'# MATLISP-UTILITIES::DEFINITIONS))
;          ,@MATLISP-UTILITIES::BODY))
;       ((TRIVIA.LEVEL2:LAMBDA-LIST MATLISP-UTILITIES::CODE &KEY (TYPE T TYPEP)
;         (MATLISP-UTILITIES::GLOBAL NIL) (MATLISP-UTILITIES::BIND (GENSYM)) &AUX
;         (BOUNDP (GENSYM)))
;        (IF MATLISP-UTILITIES::GLOBAL
;            (ALEXANDRIA.0.DEV:IF-LET (#)
;              (FIRST MATLISP-UTILITIES::CV)
;              (VALUES # #'#))
;            (PROGN
;             (PUSH # MATLISP-UTILITIES::CACHE)
;             (PUSH # MATLISP-UTILITIES::CACHE)
;             `(THE ,TYPE #)))))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN 
; --> WHEN IF LOCALLY FLET #:FN99 BLOCK LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF 
; --> LOCALLY LET LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET FLET 
; ==>
;   (#:FN98
;    (MATLISP-UTILITIES::DECL-P MATLISP-UTILITIES::BODY
;     MATLISP-UTILITIES::DECLARES MATLISP-UTILITIES::ID)
;    (DECLARE (TYPE (OR T T) MATLISP-UTILITIES::DECL-P)
;             (TYPE (OR T T) MATLISP-UTILITIES::BODY)
;             (TYPE (OR T T) MATLISP-UTILITIES::DECLARES)
;             (TYPE (OR T T) MATLISP-UTILITIES::ID))
;    (LET ((#:IT58 (CDR #:CONS43)))
;      (DECLARE (IGNORABLE #:IT58))
;      (TRIVIA.LEVEL1:TRACE-WHEN (NULL #:IT58)
;                                (LOCALLY
;                                 (DECLARE #)
;                                 (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE #)))))
; 
; caught STYLE-WARNING:
;   The variable DECL-P is defined but never used.

;     (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP-UTILITIES::TABLE
;                                     MATLISP-UTILITIES::VALUE
;                                     MATLISP-UTILITIES::EXISTS-P
;                                     MATLISP-UTILITIES::ARGS)
;       (LABELS ((MATLISP-UTILITIES::TRANSFORMER (MATLISP-UTILITIES::X)
;                  (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::X
;                    #
;                    #)))
;         (LET ((MATLISP-UTILITIES::TRANSFORMED-BODY #))
;           `(MATLISP-UTILITIES:LET*-TYPED (,@# ,@#)
;              ,@MATLISP-UTILITIES::TRANSFORMED-BODY))))
; ==>
;   (LET ((MATLISP-UTILITIES::TABLE (GENSYM "TABLE"))
;         (MATLISP-UTILITIES::VALUE (GENSYM "VALUE"))
;         (MATLISP-UTILITIES::EXISTS-P (GENSYM "EXISTS-P"))
;         (MATLISP-UTILITIES::ARGS (GENSYM "ARGS")))
;     (LABELS ((MATLISP-UTILITIES::TRANSFORMER (MATLISP-UTILITIES::X)
;                (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::X
;                  #
;                  #)))
;       (LET ((MATLISP-UTILITIES::TRANSFORMED-BODY #))
;         `(MATLISP-UTILITIES:LET*-TYPED (,@# ,@#)
;            ,@MATLISP-UTILITIES::TRANSFORMED-BODY))))
; 
; caught STYLE-WARNING:
;   The variable VALUE is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable EXISTS-P is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable ARGS is defined but never used.

;     (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::BODY
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST 'LET MATLISP-UTILITIES::BINDINGS &BODY
;          (OR # MATLISP-UTILITIES::BODY) &AUX (MATLISP-UTILITIES::DECLARES #)
;          (MATLISP-UTILITIES::ID #)))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        `(LET (,@MATLISP-UTILITIES::BINDINGS)
;           ,@MATLISP-UTILITIES::DECLARES
;           (VALUES-LIST
;            (MATLISP-UTILITIES:GETHASH! # ,MATLISP-UTILITIES::TABLE #))))
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST (AND MATLISP-UTILITIES::DEF #)
;          MATLISP-UTILITIES::NAME MATLISP-UTILITIES::FUNC-ARGS &BODY
;          (OR # MATLISP-UTILITIES::BODY) &AUX (MATLISP-UTILITIES::DECLARES #)
;          (MATLISP-UTILITIES::ID #)))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        (ASSERT (NOT (INTERSECTION '# MATLISP-UTILITIES::FUNC-ARGS)) NIL
;                "can't memoize functions with &rest, &allow-other-keys in their defining lambda-lists")
;        `(,MATLISP-UTILITIES::DEF ,MATLISP-UTILITIES::NAME
;          (,@MATLISP-UTILITIES::FUNC-ARGS) ,@MATLISP-UTILITIES::DECLARES
;          (VALUES-LIST
;           (MATLISP-UTILITIES:GETHASH! # ,MATLISP-UTILITIES::TABLE #))))
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST (AND MATLISP-UTILITIES::DEF #)
;          MATLISP-UTILITIES::DEFINITIONS &BODY MATLISP-UTILITIES::BODY))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        `(,MATLISP-UTILITIES::DEF (,@(MAPCAR #'# MATLISP-UTILITIES::DEFINITIONS))
;          ,@MATLISP-UTILITIES::BODY))
;       ((TRIVIA.LEVEL2:LAMBDA-LIST MATLISP-UTILITIES::CODE &KEY (TYPE T TYPEP)
;         (MATLISP-UTILITIES::GLOBAL NIL) (MATLISP-UTILITIES::BIND (GENSYM)) &AUX
;         (BOUNDP (GENSYM)))
;        (IF MATLISP-UTILITIES::GLOBAL
;            (ALEXANDRIA.0.DEV:IF-LET (#)
;              (FIRST MATLISP-UTILITIES::CV)
;              (VALUES # #'#))
;            (PROGN
;             (PUSH # MATLISP-UTILITIES::CACHE)
;             (PUSH # MATLISP-UTILITIES::CACHE)
;             `(THE ,TYPE #)))))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN 
; --> WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET FLET 
; ==>
;   (#:FN97
;    (MATLISP-UTILITIES::DECL-P MATLISP-UTILITIES::BODY
;     MATLISP-UTILITIES::DECLARES MATLISP-UTILITIES::ID)
;    (DECLARE (TYPE (OR T T) MATLISP-UTILITIES::DECL-P)
;             (TYPE (OR T T) MATLISP-UTILITIES::BODY)
;             (TYPE (OR T T) MATLISP-UTILITIES::DECLARES)
;             (TYPE (OR T T) MATLISP-UTILITIES::ID))
;    (LET ((#:IT41 (CDR #:CONS30)))
;      (DECLARE (IGNORABLE #:IT41))
;      (TRIVIA.LEVEL1:TRACE-WHEN (NULL #:IT41)
;                                (LOCALLY
;                                 (DECLARE #)
;                                 (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE #)))))
; 
; caught STYLE-WARNING:
;   The variable DECL-P is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/macros.lisp
; in: DEFMACRO WITH-MEMOIZATION
;     (LIST MATLISP-UTILITIES::DECL-P)
; --> CONS 
; ==>
;   MATLISP-UTILITIES::DECL-P
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

;     (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::BODY
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST 'LET MATLISP-UTILITIES::BINDINGS &BODY
;          (OR # MATLISP-UTILITIES::BODY) &AUX (MATLISP-UTILITIES::DECLARES #)
;          (MATLISP-UTILITIES::ID #)))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        `(LET (,@MATLISP-UTILITIES::BINDINGS)
;           ,@MATLISP-UTILITIES::DECLARES
;           (VALUES-LIST
;            (MATLISP-UTILITIES:GETHASH! # ,MATLISP-UTILITIES::TABLE #))))
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST (AND MATLISP-UTILITIES::DEF #)
;          MATLISP-UTILITIES::NAME MATLISP-UTILITIES::FUNC-ARGS &BODY
;          (OR # MATLISP-UTILITIES::BODY) &AUX (MATLISP-UTILITIES::DECLARES #)
;          (MATLISP-UTILITIES::ID #)))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        (ASSERT (NOT (INTERSECTION '# MATLISP-UTILITIES::FUNC-ARGS)) NIL
;                "can't memoize functions with &rest, &allow-other-keys in their defining lambda-lists")
;        `(,MATLISP-UTILITIES::DEF ,MATLISP-UTILITIES::NAME
;          (,@MATLISP-UTILITIES::FUNC-ARGS) ,@MATLISP-UTILITIES::DECLARES
;          (VALUES-LIST
;           (MATLISP-UTILITIES:GETHASH! # ,MATLISP-UTILITIES::TABLE #))))
;       ((LIST
;         (TRIVIA.LEVEL2:LAMBDA-LIST (AND MATLISP-UTILITIES::DEF #)
;          MATLISP-UTILITIES::DEFINITIONS &BODY MATLISP-UTILITIES::BODY))
;        (SETF MATLISP-UTILITIES::NEED-HASHTABLEP T)
;        `(,MATLISP-UTILITIES::DEF (,@(MAPCAR #'# MATLISP-UTILITIES::DEFINITIONS))
;          ,@MATLISP-UTILITIES::BODY))
;       ((TRIVIA.LEVEL2:LAMBDA-LIST MATLISP-UTILITIES::CODE &KEY (TYPE T TYPEP)
;         (MATLISP-UTILITIES::GLOBAL NIL) (MATLISP-UTILITIES::BIND (GENSYM)) &AUX
;         (BOUNDP (GENSYM)))
;        (IF MATLISP-UTILITIES::GLOBAL
;            (ALEXANDRIA.0.DEV:IF-LET (#)
;              (FIRST MATLISP-UTILITIES::CV)
;              (VALUES # #'#))
;            (PROGN
;             (PUSH # MATLISP-UTILITIES::CACHE)
;             (PUSH # MATLISP-UTILITIES::CACHE)
;             `(THE ,TYPE #)))))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN 
; --> WHEN IF LOCALLY FLET #:FN1265 BLOCK LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF 
; --> LOCALLY LET LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET FLET 
; ==>
;   (#:FN1264
;    (MATLISP-UTILITIES::DECL-P MATLISP-UTILITIES::BODY
;     MATLISP-UTILITIES::DECLARES MATLISP-UTILITIES::ID)
;    (DECLARE (TYPE (OR T T) MATLISP-UTILITIES::DECL-P)
;             (TYPE (OR T T) MATLISP-UTILITIES::BODY)
;             (TYPE (OR T T) MATLISP-UTILITIES::DECLARES)
;             (TYPE (OR T T) MATLISP-UTILITIES::ID))
;    (LET ((#:IT1224 (CDR #:CONS1209)))
;      (DECLARE (IGNORABLE #:IT1224))
;      (TRIVIA.LEVEL1:TRACE-WHEN (NULL #:IT1224)
;                                (LOCALLY
;                                 (DECLARE #)
;                                 (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE #)))))
; 
; caught STYLE-WARNING:
;   The variable DECL-P is defined but never used.

; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN 
; --> WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET FLET 
; ==>
;   (#:FN1263
;    (MATLISP-UTILITIES::DECL-P MATLISP-UTILITIES::BODY
;     MATLISP-UTILITIES::DECLARES MATLISP-UTILITIES::ID)
;    (DECLARE (TYPE (OR T T) MATLISP-UTILITIES::DECL-P)
;             (TYPE (OR T T) MATLISP-UTILITIES::BODY)
;             (TYPE (OR T T) MATLISP-UTILITIES::DECLARES)
;             (TYPE (OR T T) MATLISP-UTILITIES::ID))
;    (LET ((#:IT1207 (CDR #:CONS1196)))
;      (DECLARE (IGNORABLE #:IT1207))
;      (TRIVIA.LEVEL1:TRACE-WHEN (NULL #:IT1207)
;                                (LOCALLY
;                                 (DECLARE #)
;                                 (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE #)))))
; 
; caught STYLE-WARNING:
;   The variable DECL-P is defined but never used.

;     (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP-UTILITIES::TABLE
;                                     MATLISP-UTILITIES::VALUE
;                                     MATLISP-UTILITIES::EXISTS-P
;                                     MATLISP-UTILITIES::ARGS)
;       (LABELS ((MATLISP-UTILITIES::TRANSFORMER (MATLISP-UTILITIES::X)
;                  (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::X
;                    #
;                    #)))
;         (LET ((MATLISP-UTILITIES::TRANSFORMED-BODY #))
;           `(MATLISP-UTILITIES:LET*-TYPED (,@# ,@#)
;              ,@MATLISP-UTILITIES::TRANSFORMED-BODY))))
; ==>
;   (LET ((MATLISP-UTILITIES::TABLE (GENSYM "TABLE"))
;         (MATLISP-UTILITIES::VALUE (GENSYM "VALUE"))
;         (MATLISP-UTILITIES::EXISTS-P (GENSYM "EXISTS-P"))
;         (MATLISP-UTILITIES::ARGS (GENSYM "ARGS")))
;     (LABELS ((MATLISP-UTILITIES::TRANSFORMER (MATLISP-UTILITIES::X)
;                (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::X
;                  #
;                  #)))
;       (LET ((MATLISP-UTILITIES::TRANSFORMED-BODY #))
;         `(MATLISP-UTILITIES:LET*-TYPED (,@# ,@#)
;            ,@MATLISP-UTILITIES::TRANSFORMED-BODY))))
; 
; caught STYLE-WARNING:
;   The variable VALUE is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable EXISTS-P is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable ARGS is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/macros.lisp
; in: EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
;     (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
;       (DEFMACRO MATLISP-UTILITIES:USING-GENSYMS
;                 (
;                  (MATLISP-UTILITIES::DECL
;                   (&REST MATLISP-UTILITIES::SYMS)
;                   &OPTIONAL
;                   MATLISP-UTILITIES::GENSYMS)
;                  &BODY MATLISP-UTILITIES::BODY)
;         `(LET ((,MATLISP-UTILITIES::DECL #))
;            (DESTRUCTURING-BIND
;                (,@MATLISP-UTILITIES::SYMS)
;                (MAPCAR #'CAR ,MATLISP-UTILITIES::DECL)
;              ,(APPEND # MATLISP-UTILITIES::BODY))))
;       (DEFMACRO MATLISP-UTILITIES:BINDING-GENSYMS
;                 (
;                  (MATLISP-UTILITIES::MNAME
;                   &OPTIONAL
;                   (MATLISP-UTILITIES::FNAME #))
;                  &BODY MATLISP-UTILITIES::BODY)
;         `(MATLISP-UTILITIES:WITH-MEMOIZATION NIL
;            (MATLISP-UTILITIES:MEMOIZING
;             (FLET #
;               #))))
;       (DEFMACRO MATLISP-UTILITIES:SET-SLOTS
;                 (MATLISP-UTILITIES::OBJ &REST MATLISP-UTILITIES::DECL)
;         (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP-UTILITIES::G)
;           `(LET (#)
;              (SETF #)
;              ,MATLISP-UTILITIES::G)))
;       (DEFMACRO MATLISP-UTILITIES:ZIPRM
;                 ((MATLISP-UTILITIES::R MATLISP-UTILITIES::M)
;                  &BODY MATLISP-UTILITIES::ARGS)
;         "
;     Does reduce-map on @arg{args}.
;   
;     Example:
;     @lisp
;     > (macroexpand-1
;          `(ziprm (and =) (a b c) (1 2 3)))
;     => (AND (= A 1) (= B 2) (= C 3))
;     @end lisp
;     "
;         `(,MATLISP-UTILITIES::R
;           ,@(APPLY #'MAPCAR #'(LAMBDA # #)
;                    (MAPCAR #'ALEXANDRIA.0.DEV:ENSURE-LIST
;                            MATLISP-UTILITIES::ARGS))))
;       (FLET ((MATLISP-UTILITIES::CART-CASE-MACROFUNCTION
;                  (MATLISP-UTILITIES::VARS MATLISP-UTILITIES::CASES APPEND)
;                (LET #
;                  `#)))
;         (DEFMACRO MATLISP-UTILITIES:CART-CASE
;                   ((&REST MATLISP-UTILITIES::VARS)
;                    &BODY MATLISP-UTILITIES::CASES)
;           (MATLISP-UTILITIES::CART-CASE-MACROFUNCTION MATLISP-UTILITIES::VARS
;            MATLISP-UTILITIES::CASES NIL))
;         (DEFMACRO MATLISP-UTILITIES:CART-ECASE
;                   ((&REST MATLISP-UTILITIES::VARS)
;                    &BODY MATLISP-UTILITIES::CASES)
;           (MATLISP-UTILITIES::CART-CASE-MACROFUNCTION MATLISP-UTILITIES::VARS
;            MATLISP-UTILITIES::CASES `(#))))
;       (FLET ((MATLISP-UTILITIES::CART-TYPECASE-FN
;                  (MATLISP-UTILITIES::VARS MATLISP-UTILITIES::CASES APPEND)
;                (LET* #
;                  `#)))
;         (DEFMACRO MATLISP-UTILITIES:CART-TYPECASE
;                   (MATLISP-UTILITIES::VARS &BODY MATLISP-UTILITIES::CASES)
;           (MATLISP-UTILITIES::CART-TYPECASE-FN MATLISP-UTILITIES::VARS
;            MATLISP-UTILITIES::CASES NIL))
;         (DEFMACRO MATLISP-UTILITIES:CART-ETYPECASE
;                   (MATLISP-UTILITIES::VARS &BODY MATLISP-UTILITIES::CASES)
;           (MATLISP-UTILITIES::CART-TYPECASE-FN MATLISP-UTILITIES::VARS
;            MATLISP-UTILITIES::CASES `(#))))
;       (DEFMACRO MATLISP-UTILITIES:VALUES-N (MATLISP-UTILITIES::N &REST VALUES)
;         (MATLISP-UTILITIES:USING-GENSYMS (MATLISP-UTILITIES::DECL
;                                           (MATLISP-UTILITIES::N))
;           (LABELS (#)
;             `(LET #
;                #))))
;       (DEFMACRO MATLISP-UTILITIES:LETV*
;                 (MATLISP-UTILITIES::BINDINGS &BODY MATLISP-UTILITIES::BODY)
;         #<(SIMPLE-ARRAY CHARACTER (642)) 
;     This macro extends the syntax of let* to handle multiple values and destructuring bind,
;     it also handles type declarations. The declarations list @arg{vars} is similar to that in let:
;     look at th... {10042D000F}>
;         (LET ((MATLISP-UTILITIES::CONSY #))
;           (LABELS (#)
;             (APPLY #'MATLISP-UTILITIES:RECURSIVE-APPEND #))))
;       (FLET ((MATLISP-UTILITIES::LET-TYPED-EXPANSION (MATLISP-UTILITIES::EXPR)
;                (TRIVIA.LEVEL2:EMATCH MATLISP-UTILITIES::EXPR
;                  #)))
;         (DEFMACRO MATLISP-UTILITIES:LET-TYPED
;                   (MATLISP-UTILITIES::BINDINGS &BODY MATLISP-UTILITIES::BODY)
;           #<(SIMPLE-ARRAY CHARACTER (256)) 
;     This macro works basically like let, but also allows type-declarations
;     with the key :type.
;   
;     Example:
;     @lisp
;     > (macroexpand-1
;         `(let-typed ((x 1 :type fixnum))
;   	  (+ 1 x)))
;     => (LET ((X... {10042E5A4F}>
;           (MATLISP-UTILITIES::LET-TYPED-EXPANSION
;            (LIST* 'LET MATLISP-UTILITIES::BINDINGS MATLISP-UTILITIES::BODY)))
;         (DEFMACRO MATLISP-UTILITIES:LET*-TYPED
;                   (MATLISP-UTILITIES::BINDINGS &BODY MATLISP-UTILITIES::BODY)
;           #<(SIMPLE-ARRAY CHARACTER (259)) 
;     This macro works basically like let*, but also allows type-declarations
;     with the key :type.
;   
;     Example:
;     @lisp
;     > (macroexpand-1
;         `(let*-typed ((x 1 :type fixnum))
;   	  (+ 1 x)))
;     => (LET* ... {10042E63AF}>
;           (MATLISP-UTILITIES::LET-TYPED-EXPANSION
;            (LIST* 'LET* MATLISP-UTILITIES::BINDINGS MATLISP-UTILITIES::BODY))))
;       (DEFMACRO MATLISP-UTILITIES:DEFINLINE (MATLISP-UTILITIES::NAME &BODY REST)
;         "
;     Creates a function and declaims them inline: short form for defining an inlined function.
;     "
;         `(PROGN
;           (DECLAIM (INLINE ,MATLISP-UTILITIES::NAME))
;           (DEFUN ,MATLISP-UTILITIES::NAME ,@REST)))
;       ...)
; --> SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G0 (CDR #:EXPR)) (MATLISP-UTILITIES::BODY #:G0))
;     (BLOCK MATLISP-UTILITIES:MEMOIZING
;       (ERROR "Found un-expanded memoization block.")))
; 
; caught STYLE-WARNING:
;   The variable BODY is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/macros.lisp
; in: DEFMACRO MEMOIZING
;     (DEFMACRO MATLISP-UTILITIES:MEMOIZING (&REST MATLISP-UTILITIES::BODY)
;       (ERROR "Found un-expanded memoization block."))
; --> PROGN EVAL-WHEN SB-C::%DEFMACRO SB-C::%DEFMACRO SB-INT:NAMED-LAMBDA 
; --> FUNCTION SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G1543 (CDR #:EXPR)) (MATLISP-UTILITIES::BODY #:G1543))
;     (BLOCK MATLISP-UTILITIES:MEMOIZING
;       (ERROR "Found un-expanded memoization block.")))
; 
; caught STYLE-WARNING:
;   The variable BODY is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "utilities" "macros">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/search.lisp
; in: DEFINE-COMPILER-MACRO BINARY-SEARCH
;     (DEFINE-COMPILER-MACRO MATLISP-UTILITIES:BINARY-SEARCH
;         (&WHOLE MATLISP-UTILITIES::FORM MATLISP-UTILITIES::VAL
;          MATLISP-UTILITIES::LB MATLISP-UTILITIES::UB MATLISP-UTILITIES::VEC &KEY
;          (MATLISP-UTILITIES::ORDER '#'<) (MATLISP-UTILITIES::TEST '#'=))
;       (LET ((MATLISP-UTILITIES::T-CODE (MATLISP-UTILITIES:MAPTREE-EKI #'# #)))
;         `(LET (,@(MATLISP-UTILITIES:ZIP # #)
;                (MATLISP-UTILITIES::ORDER ,MATLISP-UTILITIES::ORDER)
;                (MATLISP-UTILITIES::TEST ,MATLISP-UTILITIES::TEST))
;            (DECLARE (IGNORABLE MATLISP-UTILITIES::ORDER MATLISP-UTILITIES::TEST))
;            ,@MATLISP-UTILITIES::T-CODE)))
; --> PROGN EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G0
;           (SB-C::CMACRO-CHECK-DS-LIST/&KEY (SB-C::COMPILER-MACRO-ARGS #:EXPR) 4
;                                            4
;                                            '(# MATLISP-UTILITIES::VAL
;                                              MATLISP-UTILITIES::LB
;                                              MATLISP-UTILITIES::UB
;                                              MATLISP-UTILITIES::VEC &KEY # #)
;                                            #(:ORDER :TEST)))
;          (MATLISP-UTILITIES::VAL (POP #:G0))
;          (MATLISP-UTILITIES::LB (POP #:G0))
;          (MATLISP-UTILITIES::UB (POP #:G0))
;          (MATLISP-UTILITIES::VEC (POP #:G0))
;          (#:G1 (SB-C::DS-GETF #:G0 ':ORDER))
;          (MATLISP-UTILITIES::ORDER
;           (IF (EQL #:G1 0)
;               '#'<
;               (CAR #)))
;          (#:G2 (SB-C::DS-GETF #:G0 ':TEST))
;          (MATLISP-UTILITIES::TEST
;           (IF (EQL #:G2 0)
;               '#'=
;               (CAR #))))
;     (BLOCK MATLISP-UTILITIES:BINARY-SEARCH
;       (LET ((MATLISP-UTILITIES::T-CODE #))
;         `(LET (,@# # #)
;            (DECLARE #)
;            ,@MATLISP-UTILITIES::T-CODE))))
; 
; caught STYLE-WARNING:
;   The variable VAL is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable LB is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable UB is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/search.lisp
; in: DEFINE-COMPILER-MACRO BINARY-SEARCH
;     (DEFINE-COMPILER-MACRO MATLISP-UTILITIES:BINARY-SEARCH
;         (&WHOLE MATLISP-UTILITIES::FORM MATLISP-UTILITIES::VAL
;          MATLISP-UTILITIES::LB MATLISP-UTILITIES::UB MATLISP-UTILITIES::VEC &KEY
;          (MATLISP-UTILITIES::ORDER '#'<) (MATLISP-UTILITIES::TEST '#'=))
;       (LET ((MATLISP-UTILITIES::T-CODE (MATLISP-UTILITIES:MAPTREE-EKI #'# #)))
;         `(LET (,@(MATLISP-UTILITIES:ZIP # #)
;                (MATLISP-UTILITIES::ORDER ,MATLISP-UTILITIES::ORDER)
;                (MATLISP-UTILITIES::TEST ,MATLISP-UTILITIES::TEST))
;            (DECLARE (IGNORABLE MATLISP-UTILITIES::ORDER MATLISP-UTILITIES::TEST))
;            ,@MATLISP-UTILITIES::T-CODE)))
; --> PROGN EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G0
;           (SB-C::CMACRO-CHECK-DS-LIST/&KEY (SB-C::COMPILER-MACRO-ARGS #:EXPR) 4
;                                            4
;                                            '(# MATLISP-UTILITIES::VAL
;                                              MATLISP-UTILITIES::LB
;                                              MATLISP-UTILITIES::UB
;                                              MATLISP-UTILITIES::VEC &KEY # #)
;                                            #(:ORDER :TEST)))
;          (MATLISP-UTILITIES::VAL (POP #:G0))
;          (MATLISP-UTILITIES::LB (POP #:G0))
;          (MATLISP-UTILITIES::UB (POP #:G0))
;          (MATLISP-UTILITIES::VEC (POP #:G0))
;          (#:G1 (SB-C::DS-GETF #:G0 ':ORDER))
;          (MATLISP-UTILITIES::ORDER
;           (IF (EQL #:G1 0)
;               '#'<
;               (CAR #)))
;          (#:G2 (SB-C::DS-GETF #:G0 ':TEST))
;          (MATLISP-UTILITIES::TEST
;           (IF (EQL #:G2 0)
;               '#'=
;               (CAR #))))
;     (BLOCK MATLISP-UTILITIES:BINARY-SEARCH
;       (LET ((MATLISP-UTILITIES::T-CODE #))
;         `(LET (,@# # #)
;            (DECLARE #)
;            ,@MATLISP-UTILITIES::T-CODE))))
; 
; caught STYLE-WARNING:
;   The variable UB is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable LB is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable VAL is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/search.lisp
; in: DEFINE-COMPILER-MACRO SORT-INDEX
;     (DEFINE-COMPILER-MACRO MATLISP-UTILITIES:SORT-INDEX
;         (&WHOLE MATLISP-UTILITIES::FORM MATLISP-UTILITIES::SEQ
;          MATLISP-UTILITIES::PREDICATE &KEY MATLISP-UTILITIES::KEY)
;       (LET ((MATLISP-UTILITIES::T-CODE (MATLISP-UTILITIES:MAPTREE-EKI #'# #)))
;         `(LET ((MATLISP-UTILITIES::SEQ ,MATLISP-UTILITIES::SEQ)
;                (MATLISP-UTILITIES::PREDICATE ,MATLISP-UTILITIES::PREDICATE)
;                (MATLISP-UTILITIES::KEY ,MATLISP-UTILITIES::KEY))
;            (DECLARE
;             (IGNORABLE MATLISP-UTILITIES::PREDICATE MATLISP-UTILITIES::KEY))
;            ,@MATLISP-UTILITIES::T-CODE)))
; --> PROGN EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (COMPILER-MACRO MATLISP-UTILITIES:SORT-INDEX)
;         (#:EXPR #:ENV &AUX (MATLISP-UTILITIES::FORM #:EXPR))
;       (DECLARE
;        (SB-C::LAMBDA-LIST
;         (MATLISP-UTILITIES::SEQ MATLISP-UTILITIES::PREDICATE &KEY
;          MATLISP-UTILITIES::KEY)))
;       (DECLARE (IGNORE #:ENV))
;       (SB-INT:NAMED-DS-BIND (:MACRO MATLISP-UTILITIES:SORT-INDEX
;                              . DEFINE-COMPILER-MACRO)
;           (MATLISP-UTILITIES::SEQ MATLISP-UTILITIES::PREDICATE &KEY
;            MATLISP-UTILITIES::KEY)
;           (SB-C::COMPILER-MACRO-ARGS #:EXPR)
;         (BLOCK MATLISP-UTILITIES:SORT-INDEX
;           (LET (#)
;             `(LET #
;                #
;                ,@MATLISP-UTILITIES::T-CODE)))))
; 
; caught STYLE-WARNING:
;   The variable FORM is defined but never used.

; in: DEFINE-COMPILER-MACRO SORT-INDEX
;     (DEFINE-COMPILER-MACRO MATLISP-UTILITIES:SORT-INDEX
;         (&WHOLE MATLISP-UTILITIES::FORM MATLISP-UTILITIES::SEQ
;          MATLISP-UTILITIES::PREDICATE &KEY MATLISP-UTILITIES::KEY)
;       (LET ((MATLISP-UTILITIES::T-CODE (MATLISP-UTILITIES:MAPTREE-EKI #'# #)))
;         `(LET ((MATLISP-UTILITIES::SEQ ,MATLISP-UTILITIES::SEQ)
;                (MATLISP-UTILITIES::PREDICATE ,MATLISP-UTILITIES::PREDICATE)
;                (MATLISP-UTILITIES::KEY ,MATLISP-UTILITIES::KEY))
;            (DECLARE
;             (IGNORABLE MATLISP-UTILITIES::PREDICATE MATLISP-UTILITIES::KEY))
;            ,@MATLISP-UTILITIES::T-CODE)))
; --> PROGN EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (COMPILER-MACRO MATLISP-UTILITIES:SORT-INDEX)
;         (#:EXPR #:ENV &AUX (MATLISP-UTILITIES::FORM #:EXPR))
;       (DECLARE
;        (SB-C::LAMBDA-LIST
;         (MATLISP-UTILITIES::SEQ MATLISP-UTILITIES::PREDICATE &KEY
;          MATLISP-UTILITIES::KEY)))
;       (DECLARE (IGNORE #:ENV))
;       (SB-INT:NAMED-DS-BIND (:MACRO MATLISP-UTILITIES:SORT-INDEX
;                              . DEFINE-COMPILER-MACRO)
;           (MATLISP-UTILITIES::SEQ MATLISP-UTILITIES::PREDICATE &KEY
;            MATLISP-UTILITIES::KEY)
;           (SB-C::COMPILER-MACRO-ARGS #:EXPR)
;         (BLOCK MATLISP-UTILITIES:SORT-INDEX
;           (LET (#)
;             `(LET #
;                #
;                ,@MATLISP-UTILITIES::T-CODE)))))
; 
; caught STYLE-WARNING:
;   The variable FORM is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "utilities" "search">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/lvec.lisp
; in: DEFINE-COMPILER-MACRO LVEC-COPY
;     (DEFINE-COMPILER-MACRO MATLISP-UTILITIES:LVEC-COPY
;         (&WHOLE MATLISP-UTILITIES::FORM MATLISP-UTILITIES::N ITERATE:IN
;          MATLISP-UTILITIES::OF/IN MATLISP-UTILITIES::OUT
;          MATLISP-UTILITIES::OF/OUT &KEY
;          (MATLISP-UTILITIES::KEY '#'ROW-MAJOR-AREF)
;          (MATLISP-UTILITIES::LOCK '#'(SETF ROW-MAJOR-AREF)))
;       `(LET (,@(MATLISP-UTILITIES:ZIP (SUBSEQ # 0 5)
;                                       (CDR MATLISP-UTILITIES::FORM))
;              (MATLISP-UTILITIES::KEY ,MATLISP-UTILITIES::KEY)
;              (MATLISP-UTILITIES::LOCK ,MATLISP-UTILITIES::LOCK))
;          (DECLARE (IGNORABLE MATLISP-UTILITIES::KEY MATLISP-UTILITIES::LOCK))
;          ,@(MATLISP-UTILITIES:MAPTREE-EKI
;             #'(LAMBDA (MATLISP-UTILITIES::X)
;                 (TRIVIA.LEVEL2:MATCH MATLISP-UTILITIES::X
;                   #
;                   #
;                   #
;                   #))
;             (CDDR MATLISP-UTILITIES::CODE))))
; --> PROGN EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G0
;           (SB-C::CMACRO-CHECK-DS-LIST/&KEY (SB-C::COMPILER-MACRO-ARGS #:EXPR) 5
;                                            5
;                                            '(# MATLISP-UTILITIES::N ITERATE:IN
;                                              MATLISP-UTILITIES::OF/IN
;                                              MATLISP-UTILITIES::OUT
;                                              MATLISP-UTILITIES::OF/OUT &KEY #
;                                              #)
;                                            #(:KEY :LOCK)))
;          (MATLISP-UTILITIES::N (POP #:G0))
;          (ITERATE:IN (POP #:G0))
;          (MATLISP-UTILITIES::OF/IN (POP #:G0))
;          (MATLISP-UTILITIES::OUT (POP #:G0))
;          (MATLISP-UTILITIES::OF/OUT (POP #:G0))
;          (#:G1 (SB-C::DS-GETF #:G0 ':KEY))
;          (MATLISP-UTILITIES::KEY
;           (IF (EQL #:G1 0)
;               '#'ROW-MAJOR-AREF
;               (CAR #)))
;          (#:G2 (SB-C::DS-GETF #:G0 ':LOCK))
;          (MATLISP-UTILITIES::LOCK
;           (IF (EQL #:G2 0)
;               '#'(SETF #)
;               (CAR #))))
;     (BLOCK MATLISP-UTILITIES:LVEC-COPY
;       `(LET (,@(MATLISP-UTILITIES:ZIP # #)
;              (MATLISP-UTILITIES::KEY ,MATLISP-UTILITIES::KEY)
;              (MATLISP-UTILITIES::LOCK ,MATLISP-UTILITIES::LOCK))
;          (DECLARE (IGNORABLE MATLISP-UTILITIES::KEY MATLISP-UTILITIES::LOCK))
;          ,@(MATLISP-UTILITIES:MAPTREE-EKI #'(LAMBDA # #)
;                                           (CDDR MATLISP-UTILITIES::CODE)))))
; 
; caught STYLE-WARNING:
;   The variable N is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OF/IN is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OF/OUT is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/utilities/lvec.lisp
; in: DEFINE-COMPILER-MACRO LVEC-COPY
;     (DEFINE-COMPILER-MACRO MATLISP-UTILITIES:LVEC-COPY
;         (&WHOLE MATLISP-UTILITIES::FORM MATLISP-UTILITIES::N ITERATE:IN
;          MATLISP-UTILITIES::OF/IN MATLISP-UTILITIES::OUT
;          MATLISP-UTILITIES::OF/OUT &KEY
;          (MATLISP-UTILITIES::KEY '#'ROW-MAJOR-AREF)
;          (MATLISP-UTILITIES::LOCK '#'(SETF ROW-MAJOR-AREF)))
;       `(LET (,@(MATLISP-UTILITIES:ZIP (SUBSEQ # 0 5)
;                                       (CDR MATLISP-UTILITIES::FORM))
;              (MATLISP-UTILITIES::KEY ,MATLISP-UTILITIES::KEY)
;              (MATLISP-UTILITIES::LOCK ,MATLISP-UTILITIES::LOCK))
;          (DECLARE (IGNORABLE MATLISP-UTILITIES::KEY MATLISP-UTILITIES::LOCK))
;          ,@(MATLISP-UTILITIES:MAPTREE-EKI
;             #'(LAMBDA (MATLISP-UTILITIES::X)
;                 (TRIVIA.LEVEL2:MATCH MATLISP-UTILITIES::X
;                   #
;                   #
;                   #
;                   #))
;             (CDDR MATLISP-UTILITIES::CODE))))
; --> PROGN EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO SB-INT:NAMED-LAMBDA FUNCTION 
; --> SB-INT:NAMED-DS-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G141
;           (SB-C::CMACRO-CHECK-DS-LIST/&KEY (SB-C::COMPILER-MACRO-ARGS #:EXPR) 5
;                                            5
;                                            '(# MATLISP-UTILITIES::N ITERATE:IN
;                                              MATLISP-UTILITIES::OF/IN
;                                              MATLISP-UTILITIES::OUT
;                                              MATLISP-UTILITIES::OF/OUT &KEY #
;                                              #)
;                                            #(:KEY :LOCK)))
;          (MATLISP-UTILITIES::N (POP #:G141))
;          (ITERATE:IN (POP #:G141))
;          (MATLISP-UTILITIES::OF/IN (POP #:G141))
;          (MATLISP-UTILITIES::OUT (POP #:G141))
;          (MATLISP-UTILITIES::OF/OUT (POP #:G141))
;          (#:G142 (SB-C::DS-GETF #:G141 ':KEY))
;          (MATLISP-UTILITIES::KEY
;           (IF (EQL #:G142 0)
;               '#'ROW-MAJOR-AREF
;               (CAR #)))
;          (#:G143 (SB-C::DS-GETF #:G141 ':LOCK))
;          (MATLISP-UTILITIES::LOCK
;           (IF (EQL #:G143 0)
;               '#'(SETF #)
;               (CAR #))))
;     (BLOCK MATLISP-UTILITIES:LVEC-COPY
;       `(LET (,@(MATLISP-UTILITIES:ZIP # #)
;              (MATLISP-UTILITIES::KEY ,MATLISP-UTILITIES::KEY)
;              (MATLISP-UTILITIES::LOCK ,MATLISP-UTILITIES::LOCK))
;          (DECLARE (IGNORABLE MATLISP-UTILITIES::KEY MATLISP-UTILITIES::LOCK))
;          ,@(MATLISP-UTILITIES:MAPTREE-EKI #'(LAMBDA # #)
;                                           (CDDR MATLISP-UTILITIES::CODE)))))
; 
; caught STYLE-WARNING:
;   The variable OF/OUT is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OF/IN is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable N is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "utilities" "lvec">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/ffi/ffi.lisp
; in: DEFMACRO FFUNCALL
;     (TRIVIA.LEVEL2:MATCH MATLISP-FFI::RETURN-TYPE
;       ((LIST :COMPLEX TYPE)
;        `(MATLISP-FFI:FFUNCALL (,MATLISP-FFI::NAME :VOID ,MATLISP-FFI::MODE)
;          (:& ,MATLISP-FFI::RETURN-TYPE :OUTPUT)
;          ,(COERCE 0 (MATLISP-FFI:MFFI->LISP `#)) ,@MATLISP-FFI::ARGS))
;       (MATLISP-FFI::_
;        (LET ((MATLISP-FFI::PARGS #))
;          (LABELS (#)
;            `(MATLISP-FFI::WITH-FORTRAN-FLOAT-MODES
;               #)))))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN 
; --> WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY 
; ==>
;   (LET ((TYPE (CAR #:CONS5)))
;     (LET ((#:IT6 (CDR #:CONS5)))
;       (DECLARE (IGNORABLE #:IT6))
;       (TRIVIA.LEVEL1:TRACE-WHEN (NULL #:IT6)
;                                 (LOCALLY
;                                  (DECLARE #)
;                                  (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE #)))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/ffi/ffi.lisp
; in: DEFMACRO FFUNCALL
;     (TRIVIA.LEVEL2:MATCH MATLISP-FFI::RETURN-TYPE
;       ((LIST :COMPLEX TYPE)
;        `(MATLISP-FFI:FFUNCALL (,MATLISP-FFI::NAME :VOID ,MATLISP-FFI::MODE)
;                               (:& ,MATLISP-FFI::RETURN-TYPE :OUTPUT)
;                               ,(COERCE 0 (MATLISP-FFI:MFFI->LISP `#))
;                               ,@MATLISP-FFI::ARGS))
;       (MATLISP-FFI::_
;        (LET ((MATLISP-FFI::PARGS #))
;          (LABELS (#)
;            `(MATLISP-FFI::WITH-FORTRAN-FLOAT-MODES
;               #)))))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK LET 
; --> TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN 
; --> WHEN IF LOCALLY LET TRIVIA.LEVEL1:TRACE-WHEN WHEN IF LOCALLY 
; ==>
;   (LET ((TYPE (CAR #:CONS1087)))
;     (LET ((#:IT1088 (CDR #:CONS1087)))
;       (DECLARE (IGNORABLE #:IT1088))
;       (TRIVIA.LEVEL1:TRACE-WHEN (NULL #:IT1088)
;                                 (LOCALLY
;                                  (DECLARE #)
;                                  (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE #)))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "ffi" "ffi">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/base-tensor.lisp
; in: CLOSER-MOP:DEFMETHOD INITIALIZE-INSTANCE
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (MATLISP:DIMENSIONS MATLISP::X MATLISP::I)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G54 #:G53 #:G52) (DECLARE (TYPE REAL #:G54 #:G53 #:G52)) (IF (< #:G54 #:G53) (IF (< #:G53 #:G52) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G54 #:G53 #:G52) :IN MATLISP-UTILITIES:MODPROJ)) - 
; --> SB-KERNEL:%NEGATE THE 1+ 
; ==>
;   (+ MATLISP-UTILITIES::D 1)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G54 #:G53 #:G52) (DECLARE (TYPE REAL #:G54 #:G53 #:G52)) (IF (< #:G54 #:G53) (IF (< #:G53 #:G52) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G54 #:G53 #:G52) :IN MATLISP-UTILITIES:MODPROJ)) - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1+ MATLISP-UTILITIES::D)))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G54 #:G53 #:G52) (DECLARE (TYPE REAL #:G54 #:G53 #:G52)) (IF (< #:G54 #:G53) (IF (< #:G53 #:G52) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 
; ==>
;   (< #:G54 #:G53)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G14 #:G13 #:G12) (DECLARE (TYPE REAL #:G14 #:G13 #:G12)) (IF (< #:G14 #:G13) (IF (< #:G13 #:G12) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G14 #:G13 #:G12) :IN MATLISP-UTILITIES:MODPROJ)) - 
; --> SB-KERNEL:%NEGATE THE 1+ 
; ==>
;   (+ MATLISP-UTILITIES::D 1)
; 
; note: unable to associate +/(+ -) of constants due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G14 #:G13 #:G12) (DECLARE (TYPE REAL #:G14 #:G13 #:G12)) (IF (< #:G14 #:G13) (IF (< #:G13 #:G12) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G14 #:G13 #:G12) :IN MATLISP-UTILITIES:MODPROJ)) - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1+ MATLISP-UTILITIES::D)))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G14 #:G13 #:G12) (DECLARE (TYPE REAL #:G14 #:G13 #:G12)) (IF (< #:G14 #:G13) (IF (< #:G13 #:G12) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 
; ==>
;   (< #:G14 #:G13)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a FLOAT.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G54 #:G53 #:G52) (DECLARE (TYPE REAL #:G54 #:G53 #:G52)) (IF (< #:G54 #:G53) (IF (< #:G53 #:G52) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G54 #:G53 #:G52) :IN MATLISP-UTILITIES:MODPROJ)) - 
; --> SB-KERNEL:%NEGATE THE 1+ 
; ==>
;   (+ MATLISP-UTILITIES::D 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G54 #:G53 #:G52) (DECLARE (TYPE REAL #:G54 #:G53 #:G52)) (IF (< #:G54 #:G53) (IF (< #:G53 #:G52) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G54 #:G53 #:G52) :IN MATLISP-UTILITIES:MODPROJ)) - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1+ MATLISP-UTILITIES::D)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G54 #:G53 #:G52) (DECLARE (TYPE REAL #:G54 #:G53 #:G52)) (IF (< #:G54 #:G53) (IF (< #:G53 #:G52) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 
; ==>
;   (< #:G54 #:G53)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G54 #:G53 #:G52) (DECLARE (TYPE REAL #:G54 #:G53 #:G52)) (IF (< #:G54 #:G53) (IF (< #:G53 #:G52) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF IF 
; ==>
;   (< #:G53 #:G52)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G14 #:G13 #:G12) (DECLARE (TYPE REAL #:G14 #:G13 #:G12)) (IF (< #:G14 #:G13) (IF (< #:G13 #:G12) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G14 #:G13 #:G12) :IN MATLISP-UTILITIES:MODPROJ)) - 
; --> SB-KERNEL:%NEGATE THE 1+ 
; ==>
;   (+ MATLISP-UTILITIES::D 1)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &REST T).
;       etc.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G14 #:G13 #:G12) (DECLARE (TYPE REAL #:G14 #:G13 #:G12)) (IF (< #:G14 #:G13) (IF (< #:G13 #:G12) T NIL) NIL)) 
; --> SB-C::%FUNCALL 
; --> (FUNCTION (LAMBDA (#:G14 #:G13 #:G12) :IN MATLISP-UTILITIES:MODPROJ)) - 
; ==>
;   (SB-KERNEL:%NEGATE (THE NUMBER (1+ MATLISP-UTILITIES::D)))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &REST T).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &REST T).
;       etc.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G14 #:G13 #:G12) (DECLARE (TYPE REAL #:G14 #:G13 #:G12)) (IF (< #:G14 #:G13) (IF (< #:G13 #:G12) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF 
; ==>
;   (< #:G14 #:G13)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a REAL, not a FIXNUM.

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> BLOCK COND IF IF THE PROGN ASSERT TAGBODY LET WHEN IF IF < 
; --> (LAMBDA (#:G14 #:G13 #:G12) (DECLARE (TYPE REAL #:G14 #:G13 #:G12)) (IF (< #:G14 #:G13) (IF (< #:G13 #:G12) T NIL) NIL)) 
; --> SB-C::%FUNCALL IF IF 
; ==>
;   (< #:G13 #:G12)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The second argument is a REAL, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/base-tensor.lisp
; in: DEFINLINE ORDER
;     (MATLISP-UTILITIES:DEFINLINE MATLISP:ORDER
;       (MATLISP::X)
;       (DECLARE (TYPE MATLISP::BASE-ACCESSOR MATLISP::X))
;       (LENGTH
;        (THE MATLISP:INDEX-STORE-VECTOR
;             (SLOT-VALUE MATLISP::X 'MATLISP:DIMENSIONS))))
; --> PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP:ORDER) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP:ORDER to be INLINE, but 3 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "base-tensor">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/loopy.lisp
; in: DEFMACRO OFFSET-REF
;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF MATLISP::OFFSET MATLISP:TENSOR &KEY
;                                 TYPE)
;                                MATLISP::X))
;       `(,(SECOND MATLISP::S) ,MATLISP:TENSOR ,@(WHEN TYPE `(:TYPE ,TYPE))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G13
;           (SB-C::CHECK-DS-LIST/&KEY #:G12 3 3
;                                     '(MATLISP:REF MATLISP::OFFSET
;                                       MATLISP:TENSOR &KEY TYPE)
;                                     #(:TYPE)))
;          (MATLISP:REF (POP #:G13))
;          (MATLISP::OFFSET (POP #:G13))
;          (MATLISP:TENSOR (POP #:G13))
;          (#:G14 (SB-C::DS-GETF #:G13 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      `(,(SECOND MATLISP::S) ,MATLISP:TENSOR ,@(WHEN TYPE `(:TYPE ,TYPE)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OFFSET is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF MATLISP::OFFSET MATLISP:TENSOR &KEY
;                                 TYPE)
;                                MATLISP::X))
;       `(,(FIRST MATLISP::S) (MATLISP:STORE ,(SECOND MATLISP::S))
;         ,@(WHEN TYPE `(:TYPE ,(MATLISP:STORE-TYPE TYPE)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G30
;           (SB-C::CHECK-DS-LIST/&KEY #:G29 3 3
;                                     '(MATLISP:REF MATLISP::OFFSET
;                                       MATLISP:TENSOR &KEY TYPE)
;                                     #(:TYPE)))
;          (MATLISP:REF (POP #:G30))
;          (MATLISP::OFFSET (POP #:G30))
;          (MATLISP:TENSOR (POP #:G30))
;          (#:G31 (SB-C::DS-GETF #:G30 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      `(,(FIRST MATLISP::S) (MATLISP:STORE ,(SECOND MATLISP::S))
;        ,@(WHEN TYPE `(:TYPE ,#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OFFSET is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable TENSOR is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF MATLISP::OFFSET MATLISP:TENSOR &KEY
;                                 TYPE)
;                                MATLISP::X))
;       `(,MATLISP:REF
;         ,(IF TYPE
;              `(THE ,(MATLISP:FIELD-TYPE TYPE)
;                    (MATLISP::T/STORE-REF ,TYPE ,# ,MATLISP::OFFSET))
;              `(MATLISP::STORE-REF ,(SECOND MATLISP::S) ,(FIRST MATLISP::S)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G47
;           (SB-C::CHECK-DS-LIST/&KEY #:G46 3 3
;                                     '(MATLISP:REF MATLISP::OFFSET
;                                       MATLISP:TENSOR &KEY TYPE)
;                                     #(:TYPE)))
;          (MATLISP:REF (POP #:G47))
;          (MATLISP::OFFSET (POP #:G47))
;          (MATLISP:TENSOR (POP #:G47))
;          (#:G48 (SB-C::DS-GETF #:G47 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      `(,MATLISP:REF
;        ,(IF TYPE
;             `(THE ,# #)
;             `(MATLISP::STORE-REF ,# ,#)))))
; 
; caught STYLE-WARNING:
;   The variable TENSOR is defined but never used.

;     #'(LAMBDA (MATLISP::X) (LIST (GENSYM "sto") (GENSYM)))
; 
; caught STYLE-WARNING:
;   The variable X is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/loopy.lisp
; in: DEFMACRO OFFSET-REF
;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF MATLISP::OFFSET MATLISP:TENSOR &KEY
;                                 TYPE)
;                                MATLISP::X))
;       `(,(SECOND MATLISP::S) ,MATLISP:TENSOR ,@(WHEN TYPE `(:TYPE ,TYPE))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G13
;           (SB-C::CHECK-DS-LIST/&KEY #:G12 3 3
;                                     '(MATLISP:REF MATLISP::OFFSET
;                                       MATLISP:TENSOR &KEY TYPE)
;                                     #(:TYPE)))
;          (MATLISP:REF (POP #:G13))
;          (MATLISP::OFFSET (POP #:G13))
;          (MATLISP:TENSOR (POP #:G13))
;          (#:G14 (SB-C::DS-GETF #:G13 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      `(,(SECOND MATLISP::S) ,MATLISP:TENSOR ,@(WHEN TYPE `(:TYPE ,TYPE)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OFFSET is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF MATLISP::OFFSET MATLISP:TENSOR &KEY
;                                 TYPE)
;                                MATLISP::X))
;       `(,(FIRST MATLISP::S) (MATLISP:STORE ,(SECOND MATLISP::S))
;         ,@(WHEN TYPE `(:TYPE ,(MATLISP:STORE-TYPE TYPE)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G30
;           (SB-C::CHECK-DS-LIST/&KEY #:G29 3 3
;                                     '(MATLISP:REF MATLISP::OFFSET
;                                       MATLISP:TENSOR &KEY TYPE)
;                                     #(:TYPE)))
;          (MATLISP:REF (POP #:G30))
;          (MATLISP::OFFSET (POP #:G30))
;          (MATLISP:TENSOR (POP #:G30))
;          (#:G31 (SB-C::DS-GETF #:G30 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      `(,(FIRST MATLISP::S) (MATLISP:STORE ,(SECOND MATLISP::S))
;        ,@(WHEN TYPE `(:TYPE ,#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable OFFSET is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable TENSOR is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF MATLISP::OFFSET MATLISP:TENSOR &KEY
;                                 TYPE)
;                                MATLISP::X))
;       `(,MATLISP:REF
;         ,(IF TYPE
;              `(THE ,(MATLISP:FIELD-TYPE TYPE)
;                    (MATLISP::T/STORE-REF ,TYPE ,# ,MATLISP::OFFSET))
;              `(MATLISP::STORE-REF ,(SECOND MATLISP::S) ,(FIRST MATLISP::S)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G47
;           (SB-C::CHECK-DS-LIST/&KEY #:G46 3 3
;                                     '(MATLISP:REF MATLISP::OFFSET
;                                       MATLISP:TENSOR &KEY TYPE)
;                                     #(:TYPE)))
;          (MATLISP:REF (POP #:G47))
;          (MATLISP::OFFSET (POP #:G47))
;          (MATLISP:TENSOR (POP #:G47))
;          (#:G48 (SB-C::DS-GETF #:G47 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      `(,MATLISP:REF
;        ,(IF TYPE
;             `(THE ,# #)
;             `(MATLISP::STORE-REF ,# ,#)))))
; 
; caught STYLE-WARNING:
;   The variable TENSOR is defined but never used.

;     #'(LAMBDA (MATLISP::X) (LIST (GENSYM "sto") (GENSYM)))
; 
; caught STYLE-WARNING:
;   The variable X is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "template" "loopy">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/generator.lisp
; in: CLOSER-MOP:DEFMETHOD MAKE-LOAD-FORM
;     (CLOSER-MOP:DEFMETHOD MAKE-LOAD-FORM
;       ((MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER) &OPTIONAL MATLISP::ENV)
;       (VALUES
;        `(MATLISP::CLASSP-SPECIALIZER
;          ',(CLASS-NAME (SLOT-VALUE MATLISP::OBJ 'MATLISP::OBJECT-CLASS)))
;        NIL))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD MAKE-LOAD-FORM
;                           (MATLISP::CLASSP-SPECIALIZER))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. MATLISP::OBJ &OPTIONAL
;          MATLISP::ENV)
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER MATLISP::OBJ))
;       (DECLARE (IGNORABLE MATLISP::OBJ))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((MATLISP::OBJ)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (MATLISP::OBJ) NIL
;                                                 :CALL-NEXT-METHOD-P NIL :SETQ-P
;                                                 NIL :PARAMETERS-SETQD NIL
;                                                 :METHOD-CELL (#:METHOD-CELL)
;                                                 ...)
;           (DECLARE (SB-PCL::%CLASS MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/generator.lisp
; in:
;      EVAL-EVERY (DEFINLINE LAZY-COERCE (X OUTPUT-TYPE-SPEC) (IF (TYPEP X OUTPUT-TYPE-SPEC) X (LET ((RET #)) (WHEN (SLOT-EXISTS-P X #) (ITER # #)) RET)))
;     (MATLISP-UTILITIES:EVAL-EVERY
;       (MATLISP-UTILITIES:DEFINLINE MATLISP::LAZY-COERCE
;         (MATLISP::X MATLISP::OUTPUT-TYPE-SPEC)
;         (IF (TYPEP MATLISP::X MATLISP::OUTPUT-TYPE-SPEC)
;             MATLISP::X
;             (LET (#)
;               (WHEN # #)
;               MATLISP::RET)))
;       (DEFUN MATLISP::REAL-SUBTYPEP (TYPE)
;         (TRIVIA.LEVEL2:MATCH TYPE
;           ((TRIVIA.LEVEL2:LAMBDA-LIST 'COMPLEX &OPTIONAL #) TYPE)))
;       (DEFUN MATLISP::CCLASS-MAX (&REST MATLISP::LST)
;         (ITERATE:ITER
;           (ITERATE:FOR MATLISP::ELE ITERATE:IN MATLISP::LST)
;           (ITERATE:WITH MAX)
;           (WHEN (OR # #) (SETF #))
;           (ITERATE:FINALLY (RETURN MAX))))
;       (DEFCLASS MATLISP:TENSOR-METHOD-GENERATOR
;                 (CLOSER-MOP:STANDARD-GENERIC-FUNCTION) NIL
;                 (:METACLASS SB-MOP:FUNCALLABLE-STANDARD-CLASS))
;       (DEFCLASS MATLISP::CLASSP-SPECIALIZER (SB-MOP:SPECIALIZER)
;                 ((MATLISP::OBJECT-CLASS :INITFORM NIL :INITARG :OBJECT-CLASS)
;                  (MATLISP::DIRECT-METHODS :INITFORM NIL :READER
;                   SB-MOP:SPECIALIZER-DIRECT-METHODS))
;                 (:DOCUMENTATION "Exact class specializer."))
;       (CLOSER-MOP:DEFMETHOD PRINT-OBJECT
;         ((MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER) STREAM)
;         (PRINT-UNREADABLE-OBJECT (MATLISP::OBJ STREAM :TYPE T)
;           (FORMAT STREAM ", ~a" (CLASS-NAME #))))
;       (CLOSER-MOP:DEFMETHOD SB-MOP:ADD-DIRECT-METHOD
;         ((MATLISP::SPECIALIZER MATLISP::CLASSP-SPECIALIZER) METHOD)
;         (PUSHNEW METHOD
;                  (SLOT-VALUE MATLISP::SPECIALIZER 'MATLISP::DIRECT-METHODS)))
;       (CLOSER-MOP:DEFMETHOD SB-MOP:REMOVE-DIRECT-METHOD
;         ((MATLISP::SPECIALIZER MATLISP::CLASSP-SPECIALIZER) METHOD)
;         (SETF (SLOT-VALUE MATLISP::SPECIALIZER 'MATLISP::DIRECT-METHODS)
;                 (REMOVE METHOD #)))
;       (CLOSER-MOP:DEFMETHOD MAKE-LOAD-FORM
;         ((MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER) &OPTIONAL MATLISP::ENV)
;         (VALUES `(MATLISP::CLASSP-SPECIALIZER ',(CLASS-NAME #)) NIL))
;       (DEFCLASS MATLISP::GROUP-SPECIALIZER (SB-MOP:SPECIALIZER)
;                 ((MATLISP::OBJECT-CLASS :INITFORM NIL :INITARG :OBJECT-CLASS)
;                  (MATLISP::GROUP-NAME :INITFORM NIL :INITARG :GROUP-NAME)
;                  (MATLISP::DIRECT-METHODS :INITFORM NIL :READER
;                   SB-MOP:SPECIALIZER-DIRECT-METHODS))
;                 (:DOCUMENTATION
;                  "Applicable only if for each group-specializer with distinct @argument{group-name}, the classes of the respective argument are the same."))
;       (CLOSER-MOP:DEFMETHOD PRINT-OBJECT
;         ((MATLISP::OBJ MATLISP::GROUP-SPECIALIZER) STREAM)
;         (PRINT-UNREADABLE-OBJECT (MATLISP::OBJ STREAM :TYPE T)
;           (FORMAT STREAM ", ~a, ~a" (CLASS-NAME #)
;                   (SLOT-VALUE MATLISP::OBJ 'MATLISP::GROUP-NAME))))
;       ...)
; --> PROGN LET* SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD MAKE-LOAD-FORM
;                           (MATLISP::CLASSP-SPECIALIZER))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. MATLISP::OBJ &OPTIONAL
;          MATLISP::ENV)
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER MATLISP::OBJ))
;       (DECLARE (IGNORABLE MATLISP::OBJ))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((MATLISP::OBJ)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (MATLISP::OBJ) NIL
;                                                 :CALL-NEXT-METHOD-P NIL :SETQ-P
;                                                 NIL :PARAMETERS-SETQD NIL
;                                                 :METHOD-CELL (#:METHOD-CELL)
;                                                 ...)
;           (DECLARE (SB-PCL::%CLASS MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.

;     (CLOSER-MOP:DEFMETHOD MAKE-LOAD-FORM
;       ((MATLISP::OBJ MATLISP::GROUP-SPECIALIZER) &OPTIONAL MATLISP::ENV)
;       (VALUES
;        `(MATLISP::GROUP-SPECIALIZER
;          ',(CLASS-NAME (SLOT-VALUE MATLISP::OBJ 'MATLISP::OBJECT-CLASS))
;          ',(SLOT-VALUE MATLISP::OBJ 'MATLISP::GROUP-NAME))
;        NIL))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD MAKE-LOAD-FORM
;                           (MATLISP::GROUP-SPECIALIZER))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. MATLISP::OBJ &OPTIONAL
;          MATLISP::ENV)
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER MATLISP::OBJ))
;       (DECLARE (IGNORABLE MATLISP::OBJ))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((MATLISP::OBJ)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (MATLISP::OBJ) NIL
;                                                 :CALL-NEXT-METHOD-P NIL :SETQ-P
;                                                 NIL :PARAMETERS-SETQD NIL
;                                                 :METHOD-CELL (#:METHOD-CELL)
;                                                 ...)
;           (DECLARE (SB-PCL::%CLASS MATLISP::OBJ MATLISP::GROUP-SPECIALIZER))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/generator.lisp
; in:
;      EVAL-EVERY (DEFINLINE LAZY-COERCE (X OUTPUT-TYPE-SPEC) (IF (TYPEP X OUTPUT-TYPE-SPEC) X (LET ((RET #)) (WHEN (SLOT-EXISTS-P X #) (ITER # #)) RET)))
;     (MATLISP-UTILITIES:EVAL-EVERY
;       (MATLISP-UTILITIES:DEFINLINE MATLISP::LAZY-COERCE
;         (MATLISP::X MATLISP::OUTPUT-TYPE-SPEC)
;         (IF (TYPEP MATLISP::X MATLISP::OUTPUT-TYPE-SPEC)
;             MATLISP::X
;             (LET (#)
;               (WHEN # #)
;               MATLISP::RET)))
;       (DEFUN MATLISP::REAL-SUBTYPEP (TYPE)
;         (TRIVIA.LEVEL2:MATCH TYPE
;           ((TRIVIA.LEVEL2:LAMBDA-LIST 'COMPLEX &OPTIONAL #) TYPE)))
;       (DEFUN MATLISP::CCLASS-MAX (&REST MATLISP::LST)
;         (ITERATE:ITER
;           (ITERATE:FOR MATLISP::ELE ITERATE:IN MATLISP::LST)
;           (ITERATE:WITH MAX)
;           (WHEN (OR # #) (SETF #))
;           (ITERATE:FINALLY (RETURN MAX))))
;       (DEFCLASS MATLISP:TENSOR-METHOD-GENERATOR
;                 (CLOSER-MOP:STANDARD-GENERIC-FUNCTION) NIL
;                 (:METACLASS SB-MOP:FUNCALLABLE-STANDARD-CLASS))
;       (DEFCLASS MATLISP::CLASSP-SPECIALIZER (SB-MOP:SPECIALIZER)
;                 ((MATLISP::OBJECT-CLASS :INITFORM NIL :INITARG :OBJECT-CLASS)
;                  (MATLISP::DIRECT-METHODS :INITFORM NIL :READER
;                   SB-MOP:SPECIALIZER-DIRECT-METHODS))
;                 (:DOCUMENTATION "Exact class specializer."))
;       (CLOSER-MOP:DEFMETHOD PRINT-OBJECT
;         ((MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER) STREAM)
;         (PRINT-UNREADABLE-OBJECT (MATLISP::OBJ STREAM :TYPE T)
;           (FORMAT STREAM ", ~a" (CLASS-NAME #))))
;       (CLOSER-MOP:DEFMETHOD SB-MOP:ADD-DIRECT-METHOD
;         ((MATLISP::SPECIALIZER MATLISP::CLASSP-SPECIALIZER) METHOD)
;         (PUSHNEW METHOD
;                  (SLOT-VALUE MATLISP::SPECIALIZER 'MATLISP::DIRECT-METHODS)))
;       (CLOSER-MOP:DEFMETHOD SB-MOP:REMOVE-DIRECT-METHOD
;         ((MATLISP::SPECIALIZER MATLISP::CLASSP-SPECIALIZER) METHOD)
;         (SETF (SLOT-VALUE MATLISP::SPECIALIZER 'MATLISP::DIRECT-METHODS)
;                 (REMOVE METHOD #)))
;       (CLOSER-MOP:DEFMETHOD MAKE-LOAD-FORM
;         ((MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER) &OPTIONAL MATLISP::ENV)
;         (VALUES `(MATLISP::CLASSP-SPECIALIZER ',(CLASS-NAME #)) NIL))
;       (DEFCLASS MATLISP::GROUP-SPECIALIZER (SB-MOP:SPECIALIZER)
;                 ((MATLISP::OBJECT-CLASS :INITFORM NIL :INITARG :OBJECT-CLASS)
;                  (MATLISP::GROUP-NAME :INITFORM NIL :INITARG :GROUP-NAME)
;                  (MATLISP::DIRECT-METHODS :INITFORM NIL :READER
;                   SB-MOP:SPECIALIZER-DIRECT-METHODS))
;                 (:DOCUMENTATION
;                  "Applicable only if for each group-specializer with distinct @argument{group-name}, the classes of the respective argument are the same."))
;       (CLOSER-MOP:DEFMETHOD PRINT-OBJECT
;         ((MATLISP::OBJ MATLISP::GROUP-SPECIALIZER) STREAM)
;         (PRINT-UNREADABLE-OBJECT (MATLISP::OBJ STREAM :TYPE T)
;           (FORMAT STREAM ", ~a, ~a" (CLASS-NAME #)
;                   (SLOT-VALUE MATLISP::OBJ 'MATLISP::GROUP-NAME))))
;       ...)
; --> PROGN LET* SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD MAKE-LOAD-FORM
;                           (MATLISP::GROUP-SPECIALIZER))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. MATLISP::OBJ &OPTIONAL
;          MATLISP::ENV)
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER MATLISP::OBJ))
;       (DECLARE (IGNORABLE MATLISP::OBJ))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((MATLISP::OBJ)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (MATLISP::OBJ) NIL
;                                                 :CALL-NEXT-METHOD-P NIL :SETQ-P
;                                                 NIL :PARAMETERS-SETQD NIL
;                                                 :METHOD-CELL (#:METHOD-CELL)
;                                                 ...)
;           (DECLARE (SB-PCL::%CLASS MATLISP::OBJ MATLISP::GROUP-SPECIALIZER))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.

;     (CLOSER-MOP:DEFMETHOD MAKE-LOAD-FORM
;       ((MATLISP::OBJ MATLISP::SUBTYPE-SPECIALIZER) &OPTIONAL MATLISP::ENV)
;       (VALUES
;        `(MATLISP::SUBTYPE-SPECIALIZER
;          ',(SLOT-VALUE MATLISP::OBJ 'MATLISP::SPECIALIZER-TYPE))
;        NIL))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* LET* 
; --> SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD MAKE-LOAD-FORM
;                           (MATLISP::SUBTYPE-SPECIALIZER))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. MATLISP::OBJ &OPTIONAL
;          MATLISP::ENV)
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER MATLISP::OBJ))
;       (DECLARE (IGNORABLE MATLISP::OBJ))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((MATLISP::OBJ)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (MATLISP::OBJ) NIL
;                                                 :CALL-NEXT-METHOD-P NIL :SETQ-P
;                                                 NIL :PARAMETERS-SETQD NIL
;                                                 :METHOD-CELL (#:METHOD-CELL)
;                                                 ...)
;           (DECLARE (SB-PCL::%CLASS MATLISP::OBJ MATLISP::SUBTYPE-SPECIALIZER))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/generator.lisp
; in:
;      EVAL-EVERY (DEFINLINE LAZY-COERCE (X OUTPUT-TYPE-SPEC) (IF (TYPEP X OUTPUT-TYPE-SPEC) X (LET ((RET #)) (WHEN (SLOT-EXISTS-P X #) (ITER # #)) RET)))
;     (MATLISP-UTILITIES:EVAL-EVERY
;       (MATLISP-UTILITIES:DEFINLINE MATLISP::LAZY-COERCE
;         (MATLISP::X MATLISP::OUTPUT-TYPE-SPEC)
;         (IF (TYPEP MATLISP::X MATLISP::OUTPUT-TYPE-SPEC)
;             MATLISP::X
;             (LET (#)
;               (WHEN # #)
;               MATLISP::RET)))
;       (DEFUN MATLISP::REAL-SUBTYPEP (TYPE)
;         (TRIVIA.LEVEL2:MATCH TYPE
;           ((TRIVIA.LEVEL2:LAMBDA-LIST 'COMPLEX &OPTIONAL #) TYPE)))
;       (DEFUN MATLISP::CCLASS-MAX (&REST MATLISP::LST)
;         (ITERATE:ITER
;           (ITERATE:FOR MATLISP::ELE ITERATE:IN MATLISP::LST)
;           (ITERATE:WITH MAX)
;           (WHEN (OR # #) (SETF #))
;           (ITERATE:FINALLY (RETURN MAX))))
;       (DEFCLASS MATLISP:TENSOR-METHOD-GENERATOR
;                 (CLOSER-MOP:STANDARD-GENERIC-FUNCTION) NIL
;                 (:METACLASS SB-MOP:FUNCALLABLE-STANDARD-CLASS))
;       (DEFCLASS MATLISP::CLASSP-SPECIALIZER (SB-MOP:SPECIALIZER)
;                 ((MATLISP::OBJECT-CLASS :INITFORM NIL :INITARG :OBJECT-CLASS)
;                  (MATLISP::DIRECT-METHODS :INITFORM NIL :READER
;                   SB-MOP:SPECIALIZER-DIRECT-METHODS))
;                 (:DOCUMENTATION "Exact class specializer."))
;       (CLOSER-MOP:DEFMETHOD PRINT-OBJECT
;         ((MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER) STREAM)
;         (PRINT-UNREADABLE-OBJECT (MATLISP::OBJ STREAM :TYPE T)
;           (FORMAT STREAM ", ~a" (CLASS-NAME #))))
;       (CLOSER-MOP:DEFMETHOD SB-MOP:ADD-DIRECT-METHOD
;         ((MATLISP::SPECIALIZER MATLISP::CLASSP-SPECIALIZER) METHOD)
;         (PUSHNEW METHOD
;                  (SLOT-VALUE MATLISP::SPECIALIZER 'MATLISP::DIRECT-METHODS)))
;       (CLOSER-MOP:DEFMETHOD SB-MOP:REMOVE-DIRECT-METHOD
;         ((MATLISP::SPECIALIZER MATLISP::CLASSP-SPECIALIZER) METHOD)
;         (SETF (SLOT-VALUE MATLISP::SPECIALIZER 'MATLISP::DIRECT-METHODS)
;                 (REMOVE METHOD #)))
;       (CLOSER-MOP:DEFMETHOD MAKE-LOAD-FORM
;         ((MATLISP::OBJ MATLISP::CLASSP-SPECIALIZER) &OPTIONAL MATLISP::ENV)
;         (VALUES `(MATLISP::CLASSP-SPECIALIZER ',(CLASS-NAME #)) NIL))
;       (DEFCLASS MATLISP::GROUP-SPECIALIZER (SB-MOP:SPECIALIZER)
;                 ((MATLISP::OBJECT-CLASS :INITFORM NIL :INITARG :OBJECT-CLASS)
;                  (MATLISP::GROUP-NAME :INITFORM NIL :INITARG :GROUP-NAME)
;                  (MATLISP::DIRECT-METHODS :INITFORM NIL :READER
;                   SB-MOP:SPECIALIZER-DIRECT-METHODS))
;                 (:DOCUMENTATION
;                  "Applicable only if for each group-specializer with distinct @argument{group-name}, the classes of the respective argument are the same."))
;       (CLOSER-MOP:DEFMETHOD PRINT-OBJECT
;         ((MATLISP::OBJ MATLISP::GROUP-SPECIALIZER) STREAM)
;         (PRINT-UNREADABLE-OBJECT (MATLISP::OBJ STREAM :TYPE T)
;           (FORMAT STREAM ", ~a, ~a" (CLASS-NAME #)
;                   (SLOT-VALUE MATLISP::OBJ 'MATLISP::GROUP-NAME))))
;       ...)
; --> PROGN LET* SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-PCL::FAST-METHOD MAKE-LOAD-FORM
;                           (MATLISP::SUBTYPE-SPECIALIZER))
;         (SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL. MATLISP::OBJ &OPTIONAL
;          MATLISP::ENV)
;       (DECLARE (IGNORABLE SB-PCL::.PV. SB-PCL::.NEXT-METHOD-CALL.)
;                (DISABLE-PACKAGE-LOCKS SB-PCL::PV-ENV-ENVIRONMENT))
;       (DECLARE (SB-PCL::%PARAMETER MATLISP::OBJ))
;       (DECLARE (IGNORABLE MATLISP::OBJ))
;       (SYMBOL-MACROLET ((SB-PCL::PV-ENV-ENVIRONMENT SB-PCL::DEFAULT))
;         (SB-PCL::FAST-LEXICAL-METHOD-FUNCTIONS ((MATLISP::OBJ)
;                                                 SB-PCL::.NEXT-METHOD-CALL.
;                                                 (MATLISP::OBJ) NIL
;                                                 :CALL-NEXT-METHOD-P NIL :SETQ-P
;                                                 NIL :PARAMETERS-SETQD NIL
;                                                 :METHOD-CELL (#:METHOD-CELL)
;                                                 ...)
;           (DECLARE (SB-PCL::%CLASS MATLISP::OBJ MATLISP::SUBTYPE-SPECIALIZER))
;           (LOCALLY
;            (DECLARE #)
;            (SYMBOL-MACROLET #
;              #
;              #)))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "template" "generator">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/tensor-template.lisp
; in: DEFUN LINEAR-STOREP
;     (TRIVIA.LEVEL2:MATCH (MATLISP:STORE-TYPE MATLISP:CL)
;       ((OR (LIST 'SIMPLE-ARRAY MATLISP::_ (LIST '*)) (LIST 'SIMPLE-BIT-VECTOR '*)
;            (TRIVIA.LEVEL2:GUARD MATLISP:STORE-TYPE
;             (SUBTYPEP MATLISP:STORE-TYPE 'MATLISP-FFI:FOREIGN-VECTOR)))
;        T))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK FLET 
; ==>
;   (#:FN25 (MATLISP:STORE-TYPE)
;    (DECLARE (TYPE (OR (OR T T) T) MATLISP:STORE-TYPE))
;    (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE
;      (LOCALLY
;       (TRIVIA.LEVEL1:MATCH1 NIL
;         (# T)
;         (# #)))))
; 
; caught STYLE-WARNING:
;   The variable STORE-TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/tensor-template.lisp
; in: DEFUN LINEAR-STOREP
;     (TRIVIA.LEVEL2:MATCH (MATLISP:STORE-TYPE MATLISP:CL)
;       ((OR (LIST 'SIMPLE-ARRAY MATLISP::_ (LIST '*)) (LIST 'SIMPLE-BIT-VECTOR '*)
;            (TRIVIA.LEVEL2:GUARD MATLISP:STORE-TYPE
;             (SUBTYPEP MATLISP:STORE-TYPE 'MATLISP-FFI:FOREIGN-VECTOR)))
;        T))
; --> TRIVIA.LEVEL2:MATCH2 TRIVIA.LEVEL2:MATCH2+ TRIVIA.LEVEL2:MATCH2*+ 
; --> SYMBOL-MACROLET TRIVIA.LEVEL1:MATCH1 LET BLOCK BLOCK FLET 
; ==>
;   (#:FN34 (MATLISP:STORE-TYPE)
;    (DECLARE (TYPE (OR (OR T T) T) MATLISP:STORE-TYPE))
;    (RETURN-FROM TRIVIA.LEVEL1.IMPL::WHOLE
;      (LOCALLY
;       (TRIVIA.LEVEL1:MATCH1 NIL
;         (# T)
;         (# #)))))
; 
; caught STYLE-WARNING:
;   The variable STORE-TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/tensor-template.lisp
; in: DEFINE-SETF-EXPANDER T/STORE-REF
;     (DEFINE-SETF-EXPANDER MATLISP::T/STORE-REF
;                           (MATLISP::SYM MATLISP:STORE
;                            &REST MATLISP::IDX &ENVIRONMENT MATLISP::ENV)
;       (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP::NVAL)
;         (VALUES NIL NIL `(,MATLISP::NVAL)
;                 `(MATLISP::T/STORE-SET ,MATLISP::SYM ,MATLISP::NVAL
;                                        ,MATLISP:STORE ,@MATLISP::IDX)
;                 `(MATLISP::T/STORE-REF ,MATLISP::SYM ,MATLISP:STORE
;                                        ,@MATLISP::IDX))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/tensor-template.lisp
; in: DEFINE-SETF-EXPANDER T/STORE-REF
;     (DEFINE-SETF-EXPANDER MATLISP::T/STORE-REF
;                           (MATLISP::SYM MATLISP:STORE
;                            &REST MATLISP::IDX &ENVIRONMENT MATLISP::ENV)
;       (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP::NVAL)
;         (VALUES NIL NIL `(,MATLISP::NVAL)
;                 `(MATLISP::T/STORE-SET ,MATLISP::SYM ,MATLISP::NVAL
;                                        ,MATLISP:STORE ,@MATLISP::IDX)
;                 `(MATLISP::T/STORE-REF ,MATLISP::SYM ,MATLISP:STORE
;                                        ,@MATLISP::IDX))))
; --> EVAL-WHEN SB-IMPL::%DEFSETF SB-IMPL::%DEFSETF SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA (SB-IMPL::SETF-EXPANDER MATLISP::T/STORE-REF)
;         (#:EXPR MATLISP::ENV)
;       (DECLARE
;        (SB-C::LAMBDA-LIST (MATLISP::SYM MATLISP:STORE &REST MATLISP::IDX)))
;       (SB-INT:NAMED-DS-BIND (:MACRO MATLISP::T/STORE-REF . DEFINE-SETF-EXPANDER)
;           (MATLISP::SYM MATLISP:STORE &REST MATLISP::IDX)
;           (CDR #:EXPR)
;         (BLOCK MATLISP::T/STORE-REF
;           (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP::NVAL)
;             (VALUES NIL NIL `# `# `#)))))
; 
; caught STYLE-WARNING:
;   The variable ENV is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/tensor-template.lisp
; in: CLOSER-MOP:DEFMETHOD TOTAL-SIZE
;     (MATLISP::T/TOTAL-SIZE MATLISP:DENSE-TENSOR MATLISP::X)
; --> MATLISP-UTILITIES:LVEC-FOLDR THE MATLISP:DIMENSIONS BLOCK TYPECASE LET 
; --> COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> MATLISP-UTILITIES:LVEC-FOLDR THE MATLISP:DIMENSIONS BLOCK TYPECASE LET 
; --> COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ MATLISP:ORDER BLOCK 
; --> LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> MATLISP-UTILITIES:LVEC-FOLDR THE MATLISP:DIMENSIONS BLOCK TYPECASE LET 
; --> COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "template" "tensor-template">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/generic.lisp
; in: CLOSER-MOP:DEFGENERIC COPY!
;     (MATLISP:DIMENSIONS MATLISP::X T)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/generic.lisp
; in: DEFINLINE COPY
;     (MATLISP-UTILITIES:DEFINLINE MATLISP:COPY
;       (MATLISP::OBJ &OPTIONAL TYPE)
;       (MATLISP:COPY! MATLISP::OBJ
;                      (ETYPECASE TYPE
;                        (SYMBOL TYPE)
;                        (STANDARD-CLASS (CLASS-NAME TYPE)))))
; --> PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP:COPY) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP:COPY to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/generic.lisp
; in: CLOSER-MOP:DEFMETHOD REF
;     (CLOSER-MOP:DEFMETHOD MATLISP:REF
;       :BEFORE
;       ((MATLISP::OBJ HASH-TABLE) &REST MATLISP::SUBSCRIPTS)
;       (ASSERT (AND (FIRST MATLISP::SUBSCRIPTS) (NOT (CDR MATLISP::SUBSCRIPTS)))
;               NIL 'MATLISP-CONDITIONS:INVALID-ARGUMENTS))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::OBJ &REST MATLISP::SUBSCRIPTS)
;    (ASSERT (AND (FIRST MATLISP::SUBSCRIPTS) (NOT (CDR MATLISP::SUBSCRIPTS)))
;            NIL 'MATLISP-CONDITIONS:INVALID-ARGUMENTS))
; 
; caught STYLE-WARNING:
;   The variable OBJ is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "generic">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/stride-accessor.lisp
; in: DEFINLINE STRIDES
;     (SLOT-VALUE MATLISP::X 'MATLISP:STRIDES)
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/stride-accessor.lisp
; in: DEFSTRIDE MAKE-STRIDE-RMJ
;     (MATLISP::DEFSTRIDE MATLISP::MAKE-STRIDE-RMJ NIL)
; --> MATLISP-UTILITIES:DEFINLINE PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP::MAKE-STRIDE-RMJ) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP::MAKE-STRIDE-RMJ to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "accessor" "stride-accessor">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/graph-accessor.lisp
; in: DEFINLINE FENCE
;     (MATLISP-UTILITIES:DEFINLINE MATLISP:FENCE
;       (MATLISP::G &OPTIONAL MATLISP::IDX)
;       (DECLARE (TYPE MATLISP:GRAPH-ACCESSOR MATLISP::G))
;       (TYPECASE MATLISP::IDX
;         (NULL
;          (THE MATLISP:INDEX-STORE-VECTOR (SLOT-VALUE MATLISP::G 'MATLISP:FENCE)))
;         (MATLISP:INDEX-TYPE
;          (MATLISP-UTILITIES:LET*-TYPED (# #)
;            (VALUES # #)))
;         (T (MATLISP-UTILITIES:LVEC->LIST (THE MATLISP:INDEX-STORE-VECTOR #)))))
; --> PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP:FENCE) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP:FENCE to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/graph-accessor.lisp
; in: DEFINLINE NEIGHBORS
;     (MATLISP-UTILITIES:DEFINLINE MATLISP:NEIGHBORS
;       (MATLISP::G &OPTIONAL MATLISP::I MATLISP::J)
;       (DECLARE (TYPE MATLISP:GRAPH-ACCESSOR MATLISP::G))
;       (MATLISP-UTILITIES:CART-ETYPECASE (MATLISP::I MATLISP::J)
;         ((NULL NULL)
;          (THE MATLISP:INDEX-STORE-VECTOR
;               (SLOT-VALUE MATLISP::G 'MATLISP:NEIGHBORS)))
;         ((MATLISP:INDEX-TYPE BOOLEAN)
;          (IF MATLISP::J
;              (MATLISP-UTILITIES:LETV* #
;                #)
;              (AREF # MATLISP::I)))
;         ((MATLISP:INDEX-TYPE (EQL :SIZE))
;          (MATLISP-UTILITIES:LETV* (#)
;            (- MATLISP::R MATLISP::L)))
;         ((MATLISP:INDEX-TYPE MATLISP:INDEX-TYPE)
;          (MATLISP-UTILITIES:LETV* (# #)
;            (MATLISP-UTILITIES:VERY-QUICKLY
;              #)))))
; --> PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP:NEIGHBORS) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP:NEIGHBORS to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.

;     (MATLISP:FENCE MATLISP::G MATLISP::I)
; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "accessor" "graph-accessor">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP:FROM MATLISP-CONDITIONS:PERMUTATION) (MATLISP:TO (EQL NIL)))
;       (MATLISP:COPY! MATLISP:FROM (CLASS-NAME (CLASS-OF MATLISP:FROM))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP:FROM MATLISP:TO)
;    (MATLISP:COPY! MATLISP:FROM (CLASS-NAME (CLASS-OF MATLISP:FROM))))
; 
; caught STYLE-WARNING:
;   The variable TO is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::ACT MATLISP:PERMUTATION-ACTION)
;        (TYPE (EQL 'MATLISP:PERMUTATION-CYCLE)))
;       (MATLISP-UTILITIES:LET-TYPED ((MATLISP::ARR (MATLISP:STORE MATLISP::ACT)
;                                      :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                     (MATLISP::MIDX 0 :TYPE MATLISP:INDEX-TYPE))
;         (LABELS ((MATLISP::FIND-CYCLE #
;                    #
;                    #)
;                  (MATLISP::CYCLE-WALK #
;                    #))
;           (MATLISP::WITH-NO-INIT-CHECKS
;            (MAKE-INSTANCE 'MATLISP:PERMUTATION-CYCLE :STORE # :SIZE #)))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::ACT TYPE)
;    (MATLISP-UTILITIES:LET-TYPED ((MATLISP::ARR (MATLISP:STORE MATLISP::ACT)
;                                   :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                  (MATLISP::MIDX 0 :TYPE MATLISP:INDEX-TYPE))
;      (LABELS ((MATLISP::FIND-CYCLE #
;                 #
;                 #)
;               (MATLISP::CYCLE-WALK #
;                 #))
;        (MATLISP::WITH-NO-INIT-CHECKS
;         (MAKE-INSTANCE 'MATLISP:PERMUTATION-CYCLE :STORE # :SIZE #)))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::ACT MATLISP:PERMUTATION-ACTION)
;        (TYPE (EQL 'MATLISP:PERMUTATION-PIVOT-FLIP)))
;       (MATLISP-UTILITIES:LET*-TYPED ((MATLISP::SIZE
;                                       (MATLISP::PERMUTATION-SIZE MATLISP::ACT)
;                                       :TYPE MATLISP:INDEX-TYPE)
;                                      (MATLISP::ACTR (MATLISP:STORE MATLISP::ACT)
;                                       :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                      (MATLISP::RET (MATLISP::IDXN MATLISP::SIZE)
;                                       :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                      (MATLISP::INV (MATLISP::IDXN MATLISP::SIZE)
;                                       :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                      (ITERATE:FOR (MATLISP::IDXN MATLISP::SIZE)
;                                       :TYPE MATLISP:INDEX-STORE-VECTOR))
;         (MATLISP-UTILITIES:VERY-QUICKLY
;           (LOOP :FOR MATLISP::I :OF-TYPE MATLISP:INDEX-TYPE :FROM 0 :BELOW MATLISP::SIZE
;                 :DO (LET #
;                       #)))
;         (MATLISP::WITH-NO-INIT-CHECKS
;          (MAKE-INSTANCE 'MATLISP:PERMUTATION-PIVOT-FLIP :STORE MATLISP::RET :SIZE
;                         MATLISP::SIZE))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::ACT TYPE)
;    (MATLISP-UTILITIES:LET*-TYPED ((MATLISP::SIZE
;                                    (MATLISP::PERMUTATION-SIZE MATLISP::ACT)
;                                    :TYPE MATLISP:INDEX-TYPE)
;                                   (MATLISP::ACTR (MATLISP:STORE MATLISP::ACT)
;                                    :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                   (MATLISP::RET (MATLISP::IDXN MATLISP::SIZE)
;                                    :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                   (MATLISP::INV (MATLISP::IDXN MATLISP::SIZE)
;                                    :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                   (ITERATE:FOR (MATLISP::IDXN MATLISP::SIZE)
;                                    :TYPE MATLISP:INDEX-STORE-VECTOR))
;      (MATLISP-UTILITIES:VERY-QUICKLY
;        (LOOP :FOR MATLISP::I :OF-TYPE MATLISP:INDEX-TYPE :FROM 0 :BELOW MATLISP::SIZE
;              :DO (LET #
;                    #)))
;      (MATLISP::WITH-NO-INIT-CHECKS
;       (MAKE-INSTANCE 'MATLISP:PERMUTATION-PIVOT-FLIP :STORE MATLISP::RET :SIZE
;                      MATLISP::SIZE))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::ACT MATLISP:PERMUTATION-ACTION)
;        (TYPE (EQL 'MATLISP:PERMUTATION-ACTION)))
;       (MATLISP::WITH-NO-INIT-CHECKS
;        (MAKE-INSTANCE 'MATLISP:PERMUTATION-ACTION :STORE
;                       (COPY-SEQ (MATLISP:STORE MATLISP::ACT)) :SIZE
;                       (MATLISP::PERMUTATION-SIZE MATLISP::ACT))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::ACT TYPE)
;    (MATLISP::WITH-NO-INIT-CHECKS
;     (MAKE-INSTANCE 'MATLISP:PERMUTATION-ACTION :STORE
;                    (COPY-SEQ (MATLISP:STORE MATLISP::ACT)) :SIZE
;                    (MATLISP::PERMUTATION-SIZE MATLISP::ACT))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::CYC MATLISP:PERMUTATION-CYCLE)
;        (TYPE (EQL 'MATLISP:PERMUTATION-ACTION)))
;       (MATLISP-UTILITIES:LET-TYPED ((MATLISP::ACT-REPR (MATLISP::IDXN #) :TYPE
;                                      MATLISP:INDEX-STORE-VECTOR)
;                                     (MATLISP::CYCS (MATLISP:STORE MATLISP::CYC)))
;         (MATLISP-UTILITIES:VERY-QUICKLY
;           (LOOP :FOR MATLISP::CYC :OF-TYPE MATLISP:INDEX-STORE-VECTOR :IN MATLISP::CYCS
;                 :DO (MATLISP::APPLY-CYCLE! MATLISP::ACT-REPR MATLISP::CYC)))
;         (MATLISP::WITH-NO-INIT-CHECKS
;          (MAKE-INSTANCE 'MATLISP:PERMUTATION-ACTION :STORE MATLISP::ACT-REPR
;                         :SIZE (LENGTH MATLISP::ACT-REPR)))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::CYC TYPE)
;    (MATLISP-UTILITIES:LET-TYPED ((MATLISP::ACT-REPR (MATLISP::IDXN #) :TYPE
;                                   MATLISP:INDEX-STORE-VECTOR)
;                                  (MATLISP::CYCS (MATLISP:STORE MATLISP::CYC)))
;      (MATLISP-UTILITIES:VERY-QUICKLY
;        (LOOP :FOR MATLISP::CYC :OF-TYPE MATLISP:INDEX-STORE-VECTOR :IN MATLISP::CYCS
;              :DO (MATLISP::APPLY-CYCLE! MATLISP::ACT-REPR MATLISP::CYC)))
;      (MATLISP::WITH-NO-INIT-CHECKS
;       (MAKE-INSTANCE 'MATLISP:PERMUTATION-ACTION :STORE MATLISP::ACT-REPR :SIZE
;                      (LENGTH MATLISP::ACT-REPR)))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::CYC MATLISP:PERMUTATION-CYCLE)
;        (TYPE (EQL 'MATLISP:PERMUTATION-PIVOT-FLIP)))
;       (MATLISP:COPY (MATLISP:COPY MATLISP::CYC 'MATLISP:PERMUTATION-ACTION)
;                     'MATLISP:PERMUTATION-PIVOT-FLIP))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::CYC TYPE)
;    (MATLISP:COPY (MATLISP:COPY MATLISP::CYC 'MATLISP:PERMUTATION-ACTION)
;                  'MATLISP:PERMUTATION-PIVOT-FLIP))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::CYC MATLISP:PERMUTATION-CYCLE)
;        (TYPE (EQL 'MATLISP:PERMUTATION-CYCLE)))
;       (MATLISP::WITH-NO-INIT-CHECKS
;        (MAKE-INSTANCE 'MATLISP:PERMUTATION-CYCLE :STORE
;                       (MAPCAR #'COPY-SEQ (MATLISP:STORE MATLISP::CYC)) :SIZE
;                       (MATLISP::PERMUTATION-SIZE MATLISP::CYC))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::CYC TYPE)
;    (MATLISP::WITH-NO-INIT-CHECKS
;     (MAKE-INSTANCE 'MATLISP:PERMUTATION-CYCLE :STORE
;                    (MAPCAR #'COPY-SEQ (MATLISP:STORE MATLISP::CYC)) :SIZE
;                    (MATLISP::PERMUTATION-SIZE MATLISP::CYC))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::PFLIP MATLISP:PERMUTATION-PIVOT-FLIP)
;        (TYPE (EQL 'MATLISP:PERMUTATION-ACTION)))
;       (MATLISP-UTILITIES:LET*-TYPED ((MATLISP::IDIV
;                                       (MATLISP:STORE MATLISP::PFLIP) :TYPE
;                                       MATLISP:INDEX-STORE-VECTOR)
;                                      (MATLISP::LEN
;                                       (MATLISP::PERMUTATION-SIZE MATLISP::PFLIP)
;                                       :TYPE MATLISP:INDEX-TYPE)
;                                      (MATLISP::RET (MATLISP::IDXN MATLISP::LEN)
;                                       :TYPE MATLISP:INDEX-STORE-VECTOR))
;         (MATLISP::WITH-NO-INIT-CHECKS
;          (MAKE-INSTANCE 'MATLISP:PERMUTATION-ACTION :STORE
;                         (MATLISP-UTILITIES:VERY-QUICKLY
;                           #)
;                         :SIZE MATLISP::LEN))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::PFLIP TYPE)
;    (MATLISP-UTILITIES:LET*-TYPED ((MATLISP::IDIV (MATLISP:STORE MATLISP::PFLIP)
;                                    :TYPE MATLISP:INDEX-STORE-VECTOR)
;                                   (MATLISP::LEN
;                                    (MATLISP::PERMUTATION-SIZE MATLISP::PFLIP)
;                                    :TYPE MATLISP:INDEX-TYPE)
;                                   (MATLISP::RET (MATLISP::IDXN MATLISP::LEN)
;                                    :TYPE MATLISP:INDEX-STORE-VECTOR))
;      (MATLISP::WITH-NO-INIT-CHECKS
;       (MAKE-INSTANCE 'MATLISP:PERMUTATION-ACTION :STORE
;                      (MATLISP-UTILITIES:VERY-QUICKLY
;                        #)
;                      :SIZE MATLISP::LEN))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::PFLIP MATLISP:PERMUTATION-PIVOT-FLIP)
;        (TYPE (EQL 'MATLISP:PERMUTATION-CYCLE)))
;       (MATLISP:COPY (MATLISP:COPY MATLISP::PFLIP 'MATLISP:PERMUTATION-ACTION)
;                     'MATLISP:PERMUTATION-CYCLE))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::PFLIP TYPE)
;    (MATLISP:COPY (MATLISP:COPY MATLISP::PFLIP 'MATLISP:PERMUTATION-ACTION)
;                  'MATLISP:PERMUTATION-CYCLE))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/permutation.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP::PFLIP MATLISP:PERMUTATION-PIVOT-FLIP)
;        (TYPE (EQL 'MATLISP:PERMUTATION-PIVOT-FLIP)))
;       (MATLISP::WITH-NO-INIT-CHECKS
;        (MAKE-INSTANCE 'MATLISP:PERMUTATION-PIVOT-FLIP :STORE
;                       (COPY-SEQ (MATLISP:STORE MATLISP::PFLIP)) :SIZE
;                       (MATLISP::PERMUTATION-SIZE MATLISP::PFLIP))))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::PFLIP TYPE)
;    (MATLISP::WITH-NO-INIT-CHECKS
;     (MAKE-INSTANCE 'MATLISP:PERMUTATION-PIVOT-FLIP :STORE
;                    (COPY-SEQ (MATLISP:STORE MATLISP::PFLIP)) :SIZE
;                    (MATLISP::PERMUTATION-SIZE MATLISP::PFLIP))))
; 
; caught STYLE-WARNING:
;   The variable TYPE is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "permutation">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/blas-helpers.lisp
; in: DEFUN REALTYPE-MAX
;     (FLOAT-DIGITS MATLISP::X)
; 
; note: deleting unreachable code

;     (FLOAT-DIGITS MATLISP::Y)
; ==>
;   MATLISP::Y
; 
; note: deleting unreachable code

;     (> (FLOAT-DIGITS MATLISP::X) (FLOAT-DIGITS MATLISP::Y))
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/slice.lisp
; in: DEFINLINE SLICE~
;     (MATLISP-UTILITIES:DEFINLINE MATLISP:SLICE~
;       (MATLISP::X MATLISP::AXIS &OPTIONAL (MATLISP::IDX 0)
;        (MATLISP::PRESERVE-RANK? (WHEN (= # 1) T)))
;       (MATLISP:SUBTENSOR~ MATLISP::X
;        (ITERATE:ITER
;          (ITERATE:FOR MATLISP::I MATLISP:FROM 0 MATLISP:BELOW
;           (MATLISP:ORDER MATLISP::X))
;          (ITERATE:WITH MATLISP::AXIS =
;           (MATLISP-UTILITIES:MODPROJ MATLISP::AXIS # NIL 0))
;          (ITERATE:COLLECT (COND # # #)))))
; --> PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP:SLICE~) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP:SLICE~ to be INLINE, but 2 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/base/slice.lisp
; in: DEFUN MINORS-STRIDES-PRECOMPUTE
;     (ITERATE:ITER
;       (ITERATE:FOR MATLISP::IDX ITERATE:IN MATLISP:INDICES)
;       (MATLISP-UTILITIES:LET-TYPED ((MATLISP::SV
;                                      (MATLISP::T/STORE-ALLOCATOR
;                                       MATLISP:INDEX-STORE-VECTOR #
;                                       :INITIAL-ELEMENT 0)
;                                      :TYPE MATLISP:INDEX-STORE-VECTOR))
;         (ITERATE:ITER
;           (ITERATE:FOR MATLISP::I MATLISP:FROM 0 MATLISP:BELOW
;            (LENGTH MATLISP::SV))
;           (ITERATE:FOR MATLISP::JJ ITERATE:IN MATLISP::IDX)
;           (DECLARE (TYPE MATLISP:INDEX-TYPE MATLISP::I MATLISP::JJ))
;           (SETF # #))
;         (ITERATE:COLLECT MATLISP::SV MATLISP::INTO MATLISP::STABLE
;          MATLISP::RESULT-TYPE SIMPLE-VECTOR))
;       (DECLARE (TYPE MATLISP:INDEX-TYPE MATLISP::II))
;       (ITERATE:COUNTING T MATLISP::INTO MATLISP::II)
;       (ITERATE:FINALLY (RETURN MATLISP::STABLE)))
; --> LET* BLOCK TAGBODY PROGN IF 
; ==>
;   MATLISP::II
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "base" "slice">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/maker.lisp
; in: DEFINLINE ZEROS
;     (MATLISP-UTILITIES:DEFINLINE MATLISP:ZEROS
;       (MATLISP::DIMS &OPTIONAL TYPE MATLISP::INITARG)
;       #<(SIMPLE-ARRAY CHARACTER (838)) 
;       Create a tensor with dimensions @arg{dims} of class @arg{dtype}.
;       The optional argument @arg{initarg} is used in two completely
;       incompatible ways.
;   
;       If @arg{dtype} is a dense tensor, th... {100302CE3F}>
;       (LET ((TYPE
;              (LET #
;                #)))
;         (ETYPECASE MATLISP::DIMS
;           (LIST (MATLISP::ZEROS-GENERIC MATLISP::DIMS TYPE MATLISP::INITARG))
;           (VECTOR (MATLISP::ZEROS-GENERIC # TYPE MATLISP::INITARG))
;           (FIXNUM (MATLISP::ZEROS-GENERIC # TYPE MATLISP::INITARG)))))
; --> PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP:ZEROS) (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP:ZEROS to be INLINE, but 3 calls to it were previously compiled. A declaration of NOTINLINE at the call sites will eliminate this warning, as will proclaiming and defining the function before its first potential use.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "blas" "maker">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/copy.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/copy.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (MATLISP:ZEROS (MATLISP:DIMENSIONS MATLISP:TENSOR)
;                    (OR TYPE (TYPE-OF MATLISP:TENSOR)))
; --> BLOCK LET ETYPECASE LET COND IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; --> BLOCK LET ETYPECASE LET COND IF IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/copy.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (CLOSER-MOP:DEFMETHOD MATLISP:COPY!
;       ((MATLISP:FROM MATLISP:FOREIGN-DENSE-TENSOR) (MATLISP:TO (EQL NIL)))
;       (MATLISP:COPY! MATLISP:FROM
;                      (MATLISP:TENSOR (MATLISP:FIELD-TYPE (CLASS-OF MATLISP:FROM))
;                                      'MATLISP:SIMPLE-DENSE-TENSOR)))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP:FROM MATLISP:TO)
;    (MATLISP:COPY! MATLISP:FROM
;                   (MATLISP:TENSOR (MATLISP:FIELD-TYPE (CLASS-OF MATLISP:FROM))
;                                   'MATLISP:SIMPLE-DENSE-TENSOR)))
; 
; caught STYLE-WARNING:
;   The variable TO is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/copy.lisp
; in: CLOSER-MOP:DEFMETHOD COPY!
;     (MATLISP:ZEROS (MATLISP:DIMENSIONS MATLISP:TENSOR) TYPE
;                    (IF (SUBTYPEP TYPE 'MATLISP:SPARSE-TENSOR)
;                        (MATLISP:TOTAL-SIZE MATLISP:TENSOR)))
; --> BLOCK LET ETYPECASE LET COND IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; --> BLOCK LET ETYPECASE LET COND IF IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/copy.lisp
; in: CLOSER-MOP:DEFMETHOD SWAP!
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "blas" "level-1" "copy">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/dot.lisp
; in: CLOSER-MOP:DEFGENERIC DOT
;     (MATLISP:DIMENSIONS MATLISP::X 0)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/axpy.lisp
; in: CLOSER-MOP:DEFGENERIC AXPY!
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (CLOSER-MOP:DEFGENERIC MATLISP:AXPY!
;         (MATLISP::ALPHA MATLISP::X MATLISP::Y)
;       (:DOCUMENTATION " 
;    Syntax
;    ======
;    (AXPY! alpha x y)
;   
;    Y <- alpha * x + y
;   
;    If x is T, then
;   
;    Y <- alpha + y
;   
;    Purpose
;    =======
;     Same as AXPY except that the result
;     is stored in Y and Y is returned.
;   ")
;       (:METHOD :BEFORE
;        ((MATLISP::ALPHA NUMBER) (MATLISP::X MATLISP:BASE-TENSOR)
;         (MATLISP::Y MATLISP:BASE-TENSOR))
;        (ASSERT
;         (MATLISP-UTILITIES:LVEC-EQ (MATLISP:DIMENSIONS MATLISP::X)
;                                    (MATLISP:DIMENSIONS MATLISP::Y) #'=)
;         NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH))
;       (:GENERIC-FUNCTION-CLASS MATLISP:TENSOR-METHOD-GENERATOR))
; --> PROGN EVAL-WHEN DEFGENERIC PROGN PUSH LET* LET* DEFMETHOD PROGN EVAL-WHEN 
; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::ALPHA MATLISP::X MATLISP::Y)
;    (ASSERT
;     (MATLISP-UTILITIES:LVEC-EQ (MATLISP:DIMENSIONS MATLISP::X)
;                                (MATLISP:DIMENSIONS MATLISP::Y) #'=)
;     NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH))
; 
; caught STYLE-WARNING:
;   The variable ALPHA is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "blas" "level-1" "axpy">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/scal.lisp
; in: CLOSER-MOP:DEFGENERIC SCAL!
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/scal.lisp
; in: CLOSER-MOP:DEFGENERIC DIV!
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/scal.lisp
; in: CLOSER-MOP:DEFGENERIC SCALD!
;     (MATLISP:DIMENSIONS MATLISP::X 0)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/realimag.lisp
; in: DEFINLINE MATLISP-USER:REALPART
;     (MATLISP-USER:REALPART~ MATLISP:TENSOR)
; --> BLOCK ETYPECASE LET COND IF PROGN REALPART 
; ==>
;   MATLISP:TENSOR
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/realimag.lisp
; in: DEFINLINE MATLISP-USER:IMAGPART
;     (MATLISP-USER:IMAGPART~ MATLISP:TENSOR)
; --> BLOCK ETYPECASE LET COND IF PROGN IMAGPART 
; ==>
;   MATLISP:TENSOR
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/transpose.lisp
; in: DEFINLINE CTRANSPOSE!
;     (MATLISP-USER:CONJUGATE!
;      (MATLISP:TRANSPOSE! MATLISP::A MATLISP-CONDITIONS:PERMUTATION))
; --> BLOCK ETYPECASE LET COND IF PROGN CONJUGATE 
; ==>
;   MATLISP::A
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/transpose.lisp
; in: DEFINLINE CTRANSPOSE
;     (MATLISP:CTRANSPOSE! (MATLISP:COPY MATLISP::A) MATLISP-CONDITIONS:PERMUTATION)
; --> BLOCK TYPECASE LET COND IF THE PROGN MATLISP-USER:CONJUGATE! BLOCK 
; --> ETYPECASE LET COND IF PROGN CONJUGATE 
; ==>
;   MATLISP::A
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/sum.lisp
; in: DEFUN REDUCE-CHECK
;     (MATLISP:DIMENSIONS MATLISP::X MATLISP::I)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/sum.lisp
; in: DEFGENERIC MATLISP-USER:SUM
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/sum.lisp
; in: DEFGENERIC MEAN
;     (MATLISP:DIMENSIONS MATLISP::X MATLISP::AXIS)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/sum.lisp
; in: DEFGENERIC PROD
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/gem.lisp
; in: CLOSER-MOP:DEFGENERIC GEM!
;     (CLOSER-MOP:DEFGENERIC MATLISP:GEM!
;         (MATLISP::ALPHA MATLISP::A MATLISP::B MATLISP::BETA MATLISP::C &OPTIONAL
;          MATLISP::JOB)
;       (:DOCUMENTATION
;        #<(SIMPLE-ARRAY CHARACTER (483)) 
;     Syntax
;     ======
;     (GEM! alpha a b beta c [job])
;   
;     Purpose
;     =======
;     Performs the GEneral Matrix/Vector Multiplication given by
;   	       --      -      -
;   
;   	    C <- alpha * op(A) * op(B) + beta * ... {100EF0203F}>)
;       (:METHOD :BEFORE
;        (MATLISP::ALPHA (MATLISP::A MATLISP:TENSOR) (MATLISP::B MATLISP:TENSOR)
;         MATLISP::BETA (MATLISP::C MATLISP:TENSOR) &OPTIONAL (MATLISP::JOB :NN))
;        (ASSERT (NOT (OR # #)) NIL 'MATLISP-CONDITIONS:INVALID-ARGUMENTS :MESSAGE
;                "GEM!: C = {A or B} is not allowed.")
;        (MATLISP-UTILITIES:LETV* ((# #))
;          (ASSERT (AND # # # #) NIL
;                  'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH)))
;       (:GENERIC-FUNCTION-CLASS MATLISP:TENSOR-METHOD-GENERATOR))
; --> PROGN EVAL-WHEN DEFGENERIC PROGN PUSH LET* LET* DEFMETHOD PROGN EVAL-WHEN 
; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION
;    (MATLISP::ALPHA MATLISP::A MATLISP::B MATLISP::BETA MATLISP::C &OPTIONAL
;     (MATLISP::JOB :NN))
;    (ASSERT (NOT (OR (EQ MATLISP::A MATLISP::C) (EQ MATLISP::B MATLISP::C))) NIL
;            'MATLISP-CONDITIONS:INVALID-ARGUMENTS :MESSAGE
;            "GEM!: C = {A or B} is not allowed.")
;    (MATLISP-UTILITIES:LETV* (((MATLISP::JOBA &OPTIONAL #)
;                               (MATLISP::SPLIT-JOB MATLISP::JOB)))
;      (ASSERT
;       (AND (MATLISP::TENSOR-MATRIXP MATLISP::A) (= # #)
;            (IF #
;                #
;                #)
;            (LET #
;              #))
;       NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH)))
; 
; caught STYLE-WARNING:
;   The variable ALPHA is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable BETA is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/gem.lisp
; in: CLOSER-MOP:DEFMETHOD GEM!
;     (CLOSER-MOP:DEFMETHOD MATLISP:GEM!
;       (MATLISP::ALPHA MATLISP::A (MATLISP::B MATLISP:DENSE-TENSOR) MATLISP::BETA
;        (MATLISP::C MATLISP:DENSE-TENSOR) &OPTIONAL (MATLISP::JOB :N))
;       (MATLISP:AXPY! (* MATLISP::ALPHA MATLISP::A) MATLISP::B
;                      (MATLISP:SCAL! MATLISP::BETA MATLISP::C)))
; --> DEFMETHOD PROGN EVAL-WHEN SB-PCL::%DEFMETHOD-EXPANDER 
; --> SB-PCL::LOAD-DEFMETHOD SB-PCL::LOAD-DEFMETHOD LIST* SB-INT:NAMED-LAMBDA 
; --> FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION
;    (MATLISP::ALPHA MATLISP::A MATLISP::B MATLISP::BETA MATLISP::C &OPTIONAL
;     (MATLISP::JOB :N))
;    (MATLISP:AXPY! (* MATLISP::ALPHA MATLISP::A) MATLISP::B
;                   (MATLISP:SCAL! MATLISP::BETA MATLISP::C)))
; 
; caught STYLE-WARNING:
;   The variable JOB is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "blas" "gem">
STYLE-WARNING: 6 calls to MATLISP:GEM! were compiled before a compiler-macro was defined for it. A declaration of NOTINLINE at the call sites will eliminate this warning, as will defining the compiler-macro before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/ger.lisp
; in: CLOSER-MOP:DEFGENERIC GER!
;     (MATLISP:DIMENSIONS MATLISP::X 0)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (CLOSER-MOP:DEFGENERIC MATLISP:GER!
;         (MATLISP::ALPHA MATLISP::X MATLISP::Y MATLISP::A &OPTIONAL
;          MATLISP::CONJUGATE-P)
;       (:DOCUMENTATION
;        #<(SIMPLE-ARRAY CHARACTER (317)) 
;     Syntax
;     ======
;     (GER! alpha x y A [job])
;   
;     Purpose
;     =======
;     Performs the GEneral matrix Rank-1 update given by
;   	       --             -
;   
;   	    A <- alpha * x * op(y) + A
;   
;     and returns A.
;   
;     a... {100794029F}>)
;       (:METHOD :BEFORE
;        (MATLISP::ALPHA (MATLISP::X MATLISP:DENSE-TENSOR)
;         (MATLISP::Y MATLISP:DENSE-TENSOR) (MATLISP::A MATLISP:DENSE-TENSOR)
;         &OPTIONAL MATLISP::CONJUGATE-P)
;        (DECLARE (IGNORE MATLISP::CONJUGATE-P))
;        (ASSERT
;         (AND (MATLISP::TENSOR-VECTORP MATLISP::X)
;              (MATLISP::TENSOR-VECTORP MATLISP::Y)
;              (MATLISP::TENSOR-MATRIXP MATLISP::A) (= # #) (= # #))
;         NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH))
;       (:GENERIC-FUNCTION-CLASS MATLISP:TENSOR-METHOD-GENERATOR))
; --> PROGN EVAL-WHEN DEFGENERIC PROGN PUSH LET* LET* DEFMETHOD PROGN EVAL-WHEN 
; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION
;    (MATLISP::ALPHA MATLISP::X MATLISP::Y MATLISP::A &OPTIONAL
;     MATLISP::CONJUGATE-P)
;    (DECLARE (IGNORE MATLISP::CONJUGATE-P))
;    (ASSERT
;     (AND (MATLISP::TENSOR-VECTORP MATLISP::X)
;          (MATLISP::TENSOR-VECTORP MATLISP::Y)
;          (MATLISP::TENSOR-MATRIXP MATLISP::A)
;          (= (MATLISP:DIMENSIONS MATLISP::X 0)
;             (MATLISP:DIMENSIONS MATLISP::A 0))
;          (= (MATLISP:DIMENSIONS MATLISP::Y 0)
;             (MATLISP:DIMENSIONS MATLISP::A 1)))
;     NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH))
; 
; caught STYLE-WARNING:
;   The variable ALPHA is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/ger.lisp
; in: CLOSER-MOP:DEFMETHOD GER
;     (MATLISP:DIMENSIONS MATLISP::X T)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "blas" "ger">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/blas/trs.lisp
; in: CLOSER-MOP:DEFGENERIC TRS!
;     (CLOSER-MOP:DEFGENERIC MATLISP:TRS!
;         (MATLISP::ALPHA MATLISP::A MATLISP::B &OPTIONAL MATLISP::SOLVE
;          MATLISP:UPLO)
;       (:DOCUMENTATION "Solve -> :{trans-> n/t/c}{Diag-> u/n}{Side-> l/r}")
;       (:METHOD :BEFORE
;        (MATLISP::ALPHA (MATLISP::A MATLISP:DENSE-TENSOR)
;         (MATLISP::B MATLISP:DENSE-TENSOR) &OPTIONAL (MATLISP::SOLVE :NN)
;         (MATLISP:UPLO MATLISP:*DEFAULT-UPLO*))
;        (DESTRUCTURING-BIND
;            (MATLISP::JOBA MATLISP:DIAG
;             &OPTIONAL (MATLISP::SIDE #\L MATLISP::SIDEP))
;            (MATLISP::SPLIT-JOB MATLISP::SOLVE)
;          (ASSERT (AND # # # #) NIL 'MATLISP-CONDITIONS:INVALID-ARGUMENTS)
;          (ASSERT (AND # # #) NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH)))
;       (:GENERIC-FUNCTION-CLASS MATLISP:TENSOR-METHOD-GENERATOR))
; --> PROGN EVAL-WHEN DEFGENERIC PROGN PUSH LET* LET* DEFMETHOD PROGN EVAL-WHEN 
; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION
;    (MATLISP::ALPHA MATLISP::A MATLISP::B &OPTIONAL (MATLISP::SOLVE :NN)
;     (MATLISP:UPLO MATLISP:*DEFAULT-UPLO*))
;    (DESTRUCTURING-BIND
;        (MATLISP::JOBA MATLISP:DIAG
;         &OPTIONAL (MATLISP::SIDE #\L MATLISP::SIDEP))
;        (MATLISP::SPLIT-JOB MATLISP::SOLVE)
;      (ASSERT
;       (AND (MEMBER MATLISP::JOBA '# :TEST #'CHAR=)
;            (MEMBER MATLISP::SIDE '# :TEST #'CHAR=)
;            (MEMBER MATLISP:DIAG '# :TEST #'CHAR=) (MEMBER MATLISP:UPLO '#))
;       NIL 'MATLISP-CONDITIONS:INVALID-ARGUMENTS)
;      (ASSERT
;       (AND (TYPEP MATLISP::A 'MATLISP:TENSOR-SQUARE-MATRIX)
;            (IF MATLISP::SIDEP
;                #
;                #)
;            (= # #))
;       NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH)))
; 
; caught STYLE-WARNING:
;   The variable ALPHA is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "blas" "trs">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/lapack/eig.lisp
; in: DEFUN EIG
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (MATLISP:DIMENSIONS MATLISP::X 0)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/lapack/svd.lisp
; in: CLOSER-MOP:DEFGENERIC SVD
;     (CLOSER-MOP:DEFGENERIC MATLISP:SVD
;         (MATLISP::A &OPTIONAL MATLISP::JOB)
;       (:DOCUMENTATION
;        #<(SIMPLE-ARRAY CHARACTER (1398)) 
;     Syntax
;     ======
;     (SVD a [job])
;   
;     Purpose
;     =======
;     Computes the singular value decomposition (SVD) of the 
;     NxM matrix A. The SVD of A is given by:
;   
;                    A = U * SIGMA * V'
;     
;     wh... {10050E000F}>)
;       (:METHOD :BEFORE ((MATLISP::A MATLISP:TENSOR) &OPTIONAL (MATLISP::JOB :NN))
;        (ASSERT (MEMBER MATLISP::JOB '(:NN :UN :NV :UV)) NIL
;                'MATLISP-CONDITIONS:INVALID-ARGUMENTS))
;       (:GENERIC-FUNCTION-CLASS MATLISP:TENSOR-METHOD-GENERATOR))
; --> PROGN EVAL-WHEN DEFGENERIC PROGN PUSH LET* LET* DEFMETHOD PROGN EVAL-WHEN 
; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::A &OPTIONAL (MATLISP::JOB :NN))
;    (ASSERT (MEMBER MATLISP::JOB '(:NN :UN :NV :UV)) NIL
;            'MATLISP-CONDITIONS:INVALID-ARGUMENTS))
; 
; caught STYLE-WARNING:
;   The variable A is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "core" "lapack" "svd">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/fibonacci.lisp
; in: DEFINLINE NODE-EXISTSP
;     (MATLISP-UTILITIES:DEFINLINE MATLISP-FIBONACCI:NODE-EXISTSP
;       (MATLISP-FIBONACCI::ID MATLISP-FIBONACCI::FIB)
;       (MATLISP-UTILITIES:LETV* ((MATLISP-FIBONACCI::NODE
;                                  MATLISP-FIBONACCI::EXISTS-P
;                                  (GETHASH MATLISP-FIBONACCI::ID #)))
;         (AND MATLISP-FIBONACCI::EXISTS-P
;              (MATLISP-FIBONACCI::HNODE-DCONS MATLISP-FIBONACCI::NODE) T)))
; --> PROGN DECLAIM EVAL-WHEN 
; ==>
;   (SB-C::%PROCLAIM '(INLINE MATLISP-FIBONACCI:NODE-EXISTSP)
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   Proclaiming MATLISP-FIBONACCI:NODE-EXISTSP to be INLINE, but 1 call to it was previously compiled. A declaration of NOTINLINE at the call site will eliminate this warning, as will proclaiming and defining the function before its first potential use.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/fibonacci.lisp
; in: DEFUN EXTRACT-MIN
;     (ITERATE:ITER
;       (ITERATE:FOR MATLISP-FIBONACCI::NODE MATLISP-FIBONACCI::IN-DLIST
;        (MATLISP-FIBONACCI::HNODE-CHILDREN MATLISP-FIBONACCI::Z))
;       (ITERATE:COUNTING T MATLISP-FIBONACCI::INTO MATLISP-FIBONACCI::I)
;       (SETF (MATLISP-FIBONACCI::HNODE-PARENT MATLISP-FIBONACCI::NODE) NIL)
;       (ITERATE:FINALLY
;        (INCF (MATLISP-FIBONACCI::NUMBER-OF-TREES MATLISP-FIBONACCI::FIB)
;              MATLISP-FIBONACCI::I)))
; --> LET* BLOCK TAGBODY PROGN IF 
; ==>
;   MATLISP-FIBONACCI::I
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "graph" "fibonacci">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN DEGREE
;     (MATLISP-UTILITIES:WITH-MEMOIZATION NIL
;       (ITERATE:ITER
;         (ITERATE:FOR MATLISP::I MATLISP:FROM 0 MATLISP:BELOW (1- (LENGTH #)))
;         (ITERATE:WITH MATLISP::RET =
;          (MATLISP::T/STORE-ALLOCATOR MATLISP:INDEX-STORE-VECTOR (1- #)))
;         (SETF (AREF MATLISP::RET MATLISP::I) (- # #))
;         (ITERATE:FINALLY (RETURN MATLISP::RET))))
; --> MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN ADLIST->GRAPH
;     (MATLISP:ZEROS (LIST (LENGTH MATLISP::AG) (LENGTH MATLISP::AG)) TYPE
;                    (ITERATE:ITER
;                      (ITERATE:FOR MATLISP::AI MATLISP::IN-VECTOR MATLISP::AG)
;                      (ITERATE:SUMMING (LENGTH MATLISP::AI))))
; --> BLOCK LET ETYPECASE LET COND IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; --> BLOCK LET ETYPECASE LET COND IF IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN HYPER->BIPARTITE
;     (ITERATE:ITER
;       (ITERATE:FOR MATLISP::I MATLISP:FROM 0 MATLISP:BELOW (LENGTH MATLISP::HH))
;       (SETF (AREF MATLISP::HH MATLISP::I)
;               (SORT (AREF MATLISP::HH MATLISP::I) #'<))
;       (ITERATE:ITER
;         (ITERATE:FOR MATLISP::U ITERATE:IN (AREF MATLISP::HH MATLISP::I))
;         (SETF (AREF # #) MATLISP::U)
;         (ITERATE:COUNTING T MATLISP::INTO MATLISP::J)
;         (ITERATE:FINALLY (SETF # #))))
; --> LET* BLOCK TAGBODY PROGN LET* BLOCK TAGBODY PROGN IF 
; ==>
;   MATLISP::J
; 
; note: deleting unreachable code

;     (MATLISP:ZEROS (LIST MATLISP::N MATLISP::M) (OR TYPE 'MATLISP:GRAPH-ACCESSOR)
;                    (ITERATE:ITER
;                      (ITERATE:FOR MATLISP::H MATLISP::IN-VECTOR MATLISP::HH)
;                      (ITERATE:SUMMING (LENGTH MATLISP::H))))
; --> BLOCK LET ETYPECASE LET COND IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; --> BLOCK LET ETYPECASE LET COND IF IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN CLIQUEP
;     (ITERATE:ITER
;       MATLISP::MAIN
;       (ITERATE:FOR MATLISP::U* MATLISP::ON MATLISP::LST)
;       (ITERATE:ITER
;         (ITERATE:FOR MATLISP::V ITERATE:IN (CDR MATLISP::U*))
;         (OR (MATLISP:NEIGHBORS MATLISP::G (CAR MATLISP::U*) MATLISP::V)
;             (RETURN-FROM MATLISP::MAIN NIL)))
;       (ITERATE:FINALLY (RETURN-FROM MATLISP::MAIN T)))
; --> LET* BLOCK TAGBODY PROGN LET* BLOCK TAGBODY PROGN OR LET 
; --> MATLISP:NEIGHBORS BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF 
; --> LOCALLY IF MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL MATLISP:FENCE BLOCK TYPECASE LET COND IF IF THE PROGN 
; --> MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN LET* BLOCK TAGBODY PROGN OR LET 
; --> MATLISP:NEIGHBORS BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF 
; --> LOCALLY IF MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL MATLISP:FENCE BLOCK TYPECASE LET COND IF PROGN THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN LET* BLOCK TAGBODY PROGN OR LET 
; --> MATLISP:NEIGHBORS BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF 
; --> IF LOCALLY MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL MATLISP:FENCE BLOCK TYPECASE LET COND IF IF THE PROGN 
; --> MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN LET* BLOCK TAGBODY PROGN OR LET 
; --> MATLISP:NEIGHBORS BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF 
; --> IF LOCALLY MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL MATLISP:FENCE BLOCK TYPECASE LET COND IF PROGN THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN LET* BLOCK TAGBODY PROGN OR LET 
; --> MATLISP:NEIGHBORS BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF 
; --> IF IF LOCALLY MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL MATLISP:FENCE BLOCK TYPECASE LET COND IF IF THE PROGN 
; --> MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN LET* BLOCK TAGBODY PROGN OR LET 
; --> MATLISP:NEIGHBORS BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF 
; --> IF IF LOCALLY MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND 
; --> MULTIPLE-VALUE-CALL MATLISP:FENCE BLOCK TYPECASE LET COND IF PROGN THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN GRAPH-QUEUE
;     (MATLISP:FENCE MATLISP::G)
; --> BLOCK TYPECASE LET COND IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN DIJKSTRA
;     (MATLISP:GRAPHFIB
;      (MATLISP::G MATLISP::G :ORDER
;       (LAMBDA (MATLISP::X MATLISP::Y)
;         (IF (AND MATLISP::X MATLISP::Y)
;             (< MATLISP::X MATLISP::Y)
;             (AND MATLISP::X T))))
;      (:INIT (MATLISP::I)
;       (IF (= MATLISP::I MATLISP::START)
;           0
;           NIL))
;      (:UPDATE (MATLISP::I MATLISP::D-I MATLISP::FIB)
;       (MATLISP-UTILITIES:LETV* ((MATLISP::LI MATLISP::RI #))
;         (ITERATE:ITER
;           (ITERATE:FOR MATLISP::J MATLISP::IN-VECTOR # MATLISP:FROM MATLISP::LI
;            MATLISP:BELOW MATLISP::RI)
;           (WHEN # #))))
;      MATLISP::TREE)
; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET 
; --> COND IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET 
; --> COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED 
; ==>
;   (LET* ((MATLISP::G MATLISP::G)
;          (#:FE2 (MATLISP:FENCE MATLISP::G))
;          (MATLISP::FIB
;           (LET* (#)
;             (ITERATE:ITER
;               #
;               #)
;             #:QUEUE3)))
;     (DECLARE (TYPE MATLISP:INDEX-STORE-VECTOR #:FE2)
;              (TYPE MATLISP:GRAPH-ACCESSOR MATLISP::G))
;     (ITERATE:ITER
;       (ITERATE:UNTIL (= (MATLISP:TOTAL-SIZE MATLISP::FIB) 0))
;       (MATLISP-UTILITIES:LETV* ((MATLISP::D-I MATLISP::I # :TYPE T
;                                  MATLISP:INDEX-TYPE))
;         (MATLISP-UTILITIES:LETV* (#)
;           (ITERATE:ITER
;             #
;             #))))
;     MATLISP::TREE)
; 
; caught STYLE-WARNING:
;   The variable #:FE2 is defined but never used.

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN SETQ THE 1- - LENGTH MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN SETQ THE 1- - LENGTH MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN DIJKSTRA-PRIMS
;     (MATLISP:GRAPHFIB
;      (MATLISP::G MATLISP::G :ORDER
;       (LAMBDA (MATLISP::X MATLISP::Y)
;         (IF (AND MATLISP::X MATLISP::Y)
;             (< MATLISP::X MATLISP::Y)
;             (AND MATLISP::X T))))
;      (:INIT (MATLISP::I)
;       (IF (= MATLISP::I MATLISP::START)
;           0
;           NIL))
;      (:UPDATE (MATLISP::I MATLISP::W-I MATLISP::FIB)
;       (MATLISP-UTILITIES:LETV* ((MATLISP::LI MATLISP::RI #))
;         (ITERATE:ITER
;           (ITERATE:FOR MATLISP::J MATLISP::IN-VECTOR # MATLISP:FROM MATLISP::LI
;            MATLISP:BELOW MATLISP::RI)
;           (WHEN # #))))
;      MATLISP::TREE)
; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET 
; --> COND IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET 
; --> COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED 
; ==>
;   (LET* ((MATLISP::G MATLISP::G)
;          (#:FE2 (MATLISP:FENCE MATLISP::G))
;          (MATLISP::FIB
;           (LET* (#)
;             (ITERATE:ITER
;               #
;               #)
;             #:QUEUE3)))
;     (DECLARE (TYPE MATLISP:INDEX-STORE-VECTOR #:FE2)
;              (TYPE MATLISP:GRAPH-ACCESSOR MATLISP::G))
;     (ITERATE:ITER
;       (ITERATE:UNTIL (= (MATLISP:TOTAL-SIZE MATLISP::FIB) 0))
;       (MATLISP-UTILITIES:LETV* ((MATLISP::W-I MATLISP::I # :TYPE T
;                                  MATLISP:INDEX-TYPE))
;         (MATLISP-UTILITIES:LETV* (#)
;           (ITERATE:ITER
;             #
;             #))))
;     MATLISP::TREE)
; 
; caught STYLE-WARNING:
;   The variable #:FE2 is defined but never used.

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN SETQ THE 1- - LENGTH MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN SETQ THE 1- - LENGTH MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* ITERATE:ITER LET* BLOCK TAGBODY 
; --> PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; ==>
;   #'(LAMBDA (&OPTIONAL (MATLISP::W-I) (MATLISP::I) &REST #:G10)
;       (DECLARE (IGNORE #:G10))
;       (DECLARE (TYPE T MATLISP::W-I)
;                (TYPE MATLISP:INDEX-TYPE MATLISP::I))
;       (LOCALLY
;        (MULTIPLE-VALUE-BIND (MATLISP::LI MATLISP::RI)
;            (MATLISP:FENCE MATLISP::G MATLISP::I)
;          (LOCALLY
;           (LET* #
;             #)))))
; 
; caught STYLE-WARNING:
;   The variable W-I is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graph.lisp
; in: DEFUN MAX-DAG
;     (MATLISP:GRAPHFIB
;      (MATLISP::G MATLISP::G :ORDER
;       #'(LAMBDA (MATLISP::A MATLISP::B)
;           (< (FIRST MATLISP::A) (FIRST MATLISP::B))))
;      (:INIT (MATLISP::I)
;       (LIST (MATLISP:NEIGHBORS MATLISP::G MATLISP::I :SIZE)
;             (MATLISP:NEIGHBORS MATLISP::GT MATLISP::I :SIZE)))
;      (:UPDATE (MATLISP::I MATLISP::D-I MATLISP::FIB)
;       (MAP NIL #'(LAMBDA (MATLISP::V) (WHEN # #))
;            (MATLISP:NEIGHBORS MATLISP::GT MATLISP::I T))
;       (MAP NIL #'(LAMBDA (MATLISP::V) (WHEN # #))
;            (MATLISP:NEIGHBORS MATLISP::G MATLISP::I T))
;       (IF (>= (FIRST MATLISP::D-I) (SECOND MATLISP::D-I))
;           (MAP NIL #'(LAMBDA # #) (MATLISP:NEIGHBORS MATLISP::G MATLISP::I T))
;           (MAP NIL #'(LAMBDA # #) (MATLISP:NEIGHBORS MATLISP::GT MATLISP::I T))))
;      (MATLISP:ADLIST->GRAPH MATLISP::ADG (TYPE-OF MATLISP::G)))
; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET 
; --> COND IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* MATLISP:FENCE BLOCK TYPECASE LET 
; --> COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED 
; ==>
;   (LET* ((MATLISP::G MATLISP::G)
;          (#:FE0 (MATLISP:FENCE MATLISP::G))
;          (MATLISP::FIB
;           (LET* (#)
;             (ITERATE:ITER
;               #
;               #)
;             #:QUEUE1)))
;     (DECLARE (TYPE MATLISP:INDEX-STORE-VECTOR #:FE0)
;              (TYPE MATLISP:GRAPH-ACCESSOR MATLISP::G))
;     (ITERATE:ITER
;       (ITERATE:UNTIL (= (MATLISP:TOTAL-SIZE MATLISP::FIB) 0))
;       (MATLISP-UTILITIES:LETV* ((MATLISP::D-I MATLISP::I # :TYPE T
;                                  MATLISP:INDEX-TYPE))
;         (MAP NIL #'(LAMBDA # #) (MATLISP:NEIGHBORS MATLISP::GT MATLISP::I T))
;         (MAP NIL #'(LAMBDA # #) (MATLISP:NEIGHBORS MATLISP::G MATLISP::I T))
;         (IF (>= # #)
;             (MAP NIL #'# #)
;             (MAP NIL #'# #))))
;     (MATLISP:ADLIST->GRAPH MATLISP::ADG (TYPE-OF MATLISP::G)))
; 
; caught STYLE-WARNING:
;   The variable #:FE0 is defined but never used.

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN SETQ THE 1- - LENGTH MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF PROGN MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN SETQ THE 1- - LENGTH MATLISP:FENCE BLOCK TYPECASE LET COND 
; --> IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF LOCALLY THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF LOCALLY IF 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF LOCALLY IF 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF LOCALLY IF 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF IF PROGN 
; --> MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF LOCALLY IF 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF IF THE PROGN 
; --> MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF LOCALLY IF AREF THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF IF IF LOCALLY 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF IF IF LOCALLY 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF IF IF LOCALLY 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF IF PROGN 
; --> MATLISP-UTILITIES:LET*-TYPED LET* SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF IF IF LOCALLY 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF IF THE PROGN 
; --> MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF LOCALLY IF 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE 
; ==>
;   MATLISP::I
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF LOCALLY IF AREF 
; ==>
;   MATLISP::I
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF IF IF LOCALLY 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE 
; ==>
;   MATLISP::I
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF IF LOCALLY 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF IF THE PROGN 
; --> MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; --> BLOCK MATLISP-UTILITIES:LET*-TYPED LET* LET* ITERATE:ITER LET* BLOCK 
; --> TAGBODY PROGN MATLISP-FIBONACCI:INSERT-KEY PROGN LIST MATLISP:NEIGHBORS 
; --> BLOCK MATLISP-UTILITIES:CART-ETYPECASE LET COND IF IF IF LOCALLY 
; --> MATLISP-UTILITIES:LETV* MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "graph" "graph">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/graph/graphviz.lisp
; in: DEFUN GRAPH->DOT
;     (ITERATE:ITER
;       (ITERATE:FOR MATLISP::U MATLISP:FROM 0 MATLISP:BELOW
;        (MATLISP:DIMENSIONS MATLISP::G -1))
;       (MATLISP-UTILITIES:LETV* ((MATLISP::LB MATLISP::UB
;                                  (MATLISP:FENCE MATLISP::G MATLISP::U)))
;         (ITERATE:ITER
;           (ITERATE:FOR MATLISP::V MATLISP::IN-VECTOR
;            (MATLISP:NEIGHBORS MATLISP::G) MATLISP:FROM MATLISP::LB MATLISP:BELOW
;            MATLISP::UB)
;           (WHEN (OR # #) (ITERATE:NEXT-ITERATION))
;           (FORMAT STREAM
;                   (MATLISP-UTILITIES:STRING+ "~a->~a [" # "label=\"\",];~%")
;                   MATLISP::V MATLISP::U))))
; --> LET* BLOCK TAGBODY PROGN MULTIPLE-VALUE-BIND MULTIPLE-VALUE-CALL 
; --> MATLISP:FENCE BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::G
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/user/function.lisp
; in: DEFINLINE LOG
;     (MATLISP:ZEROS (MATLISP:DIMENSIONS MATLISP-USER::POWER)
;                    (MATLISP:TENSOR
;                     (LET ((TYPE #))
;                       (IF (SUBTYPEP TYPE 'COMPLEX)
;                           TYPE
;                           `(COMPLEX ,TYPE)))))
; --> BLOCK LET ETYPECASE LET COND IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; --> BLOCK LET ETYPECASE LET COND IF IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/map.lisp
; in: CLOSER-MOP:DEFGENERIC MAP-TENSOR!
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (CLOSER-MOP:DEFGENERIC MATLISP:MAP-TENSOR!
;         (MATLISP::FUNC MATLISP::X MATLISP::Y)
;       (:DOCUMENTATION
;        #<(SIMPLE-ARRAY CHARACTER (451)) 
;       Syntax
;       ======
;       (MAP-TENSOR! func x y)
;   
;       Purpose
;       =======
;       Applies the function element-wise on x, and sets the corresponding
;       elements in y to the value returned by the functio... {100E8C2E5F}>)
;       (:METHOD :BEFORE
;        ((MATLISP::FUNC FUNCTION) (MATLISP::X MATLISP:TENSOR)
;         (MATLISP::Y MATLISP:TENSOR))
;        (ASSERT
;         (MATLISP-UTILITIES:VERY-QUICKLY
;           (MATLISP-UTILITIES:LVEC-EQ # #))
;         NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH))
;       (:GENERIC-FUNCTION-CLASS MATLISP:TENSOR-METHOD-GENERATOR))
; --> PROGN EVAL-WHEN DEFGENERIC PROGN PUSH LET* LET* DEFMETHOD PROGN EVAL-WHEN 
; --> SB-PCL::%DEFMETHOD-EXPANDER SB-PCL::LOAD-DEFMETHOD LIST* 
; --> SB-INT:NAMED-LAMBDA FUNCTION FLET FLET 
; ==>
;   (#:METHOD-FUNCTION (MATLISP::FUNC MATLISP::X MATLISP::Y)
;    (ASSERT
;     (MATLISP-UTILITIES:VERY-QUICKLY
;       (MATLISP-UTILITIES:LVEC-EQ (MATLISP:DIMENSIONS MATLISP::X)
;                                  (MATLISP:DIMENSIONS MATLISP::Y)))
;     NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH))
; 
; caught STYLE-WARNING:
;   The variable FUNC is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/map.lisp
; in: DEFINLINE MAP-TENSOR
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/map.lisp
; in: DEFUN CHECK-DIMS
;     (ITERATE:ITER
;       (ITERATE:FOR MATLISP::X ITERATE:IN MATLISP::TENSORS)
;       (ITERATE:FOR MATLISP::AXIS ITERATE:IN MATLISP::AXLST)
;       (ITERATE:WITH MATLISP::DIMS = NIL)
;       (COND
;        ((TYPEP MATLISP::X 'MATLISP:DENSE-TENSOR)
;         (MATLISP-UTILITIES:LET-TYPED (#)
;           (ASSERT # NIL 'MATLISP-CONDITIONS:TENSOR-DIMENSION-MISMATCH)
;           (IF #
;               #
;               #))
;         (ITERATE:COLLECT (AREF # #) MATLISP::INTO MATLISP:STRIDES)
;         (ITERATE:COLLECT (MATLISP:SLICE~ MATLISP::X MATLISP::AXIS 0 #)
;          MATLISP::INTO MATLISP::SLICES))
;        ((EQ MATLISP::X NIL) (ITERATE:COLLECT NIL MATLISP::INTO MATLISP:STRIDES)
;         (ITERATE:COLLECT NIL MATLISP::INTO MATLISP::SLICES))
;        (T (ERROR 'MATLISP-CONDITIONS:INVALID-ARGUMENTS)))
;       (ITERATE:FINALLY
;        (RETURN (VALUES MATLISP::DIMS MATLISP:STRIDES MATLISP::SLICES))))
; --> LET* BLOCK TAGBODY PROGN IF PROGN LET MATLISP:DIMENSIONS BLOCK TYPECASE 
; --> LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN IF PROGN LET MATLISP:DIMENSIONS BLOCK TYPECASE 
; --> LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN IF PROGN LET MATLISP:DIMENSIONS BLOCK TYPECASE 
; --> LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ MATLISP:ORDER 
; --> BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN IF PROGN LET MATLISP:DIMENSIONS BLOCK TYPECASE 
; --> LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN IF PROGN PROGN SETQ THE LIST CONS AREF 
; --> MATLISP:STRIDES BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN IF PROGN PROGN SETQ THE LIST CONS AREF 
; --> MATLISP:STRIDES BLOCK TYPECASE LET COND IF IF PROGN THE AREF 
; --> MATLISP-UTILITIES:MODPROJ MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN IF PROGN PROGN SETQ THE LIST CONS AREF 
; --> MATLISP:STRIDES BLOCK TYPECASE LET COND IF IF PROGN THE AREF 
; --> MATLISP-UTILITIES:MODPROJ MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> LET* BLOCK TAGBODY PROGN IF PROGN PROGN SETQ THE LIST CONS AREF 
; --> MATLISP:STRIDES BLOCK TYPECASE LET COND IF IF THE PROGN 
; --> MATLISP-UTILITIES:LVEC->LIST THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "special" "map">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/misc.lisp
; in: DEFUN RANGE
;     (MATLISP:ZEROS MATLISP::QUO (MATLISP:TENSOR TYPE))
; --> BLOCK LET ETYPECASE LET COND IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; --> BLOCK LET ETYPECASE LET COND IF IF PROGN MATLISP::ZEROS-GENERIC 
; ==>
;   TYPE
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/misc.lisp
; in: DEFUN ONES
;     (THE MATLISP:DENSE-TENSOR (MATLISP:ZEROS MATLISP::DIMS TYPE 1))
; 
; note: type assertion too complex to check:
; (VALUES MATLISP:DENSE-TENSOR &REST T).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/poly.lisp
; in: DEFUN POLYFIT
;     (MATLISP:DIMENSIONS MATLISP::X 0)
; --> BLOCK TYPECASE LET COND IF PROGN THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/optimize.lisp
; in: DEFMACRO OPTIMIZE-EXPRESSION
;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                             MATLISP:STRIDES &ALLOW-OTHER-KEYS)
;                                (ASSOC MATLISP::VEC MATLISP::DECL)))
;       (OR MATLISP:STRIDES
;           (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STRIDES)
;             (VALUES MATLISP:STRIDES `(#)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G53
;           (SB-C::CHECK-DS-LIST/&KEY #:G52 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                                   MATLISP:STRIDES
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G53))
;          (TRIVIA.LEVEL2:PLACE (POP #:G53))
;          (#:G54 (SB-C::DS-GETF #:G53 ':STRIDES))
;          (MATLISP:STRIDES
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (OR MATLISP:STRIDES
;          (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STRIDES)
;            (VALUES MATLISP:STRIDES `#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                             MATLISP:STORE &ALLOW-OTHER-KEYS)
;                                (ASSOC MATLISP::VEC MATLISP::DECL)))
;       (OR MATLISP:STORE
;           (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STORE)
;             (VALUES MATLISP:STORE `(#)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G40
;           (SB-C::CHECK-DS-LIST/&KEY #:G39 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                                   MATLISP:STORE
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G40))
;          (TRIVIA.LEVEL2:PLACE (POP #:G40))
;          (#:G41 (SB-C::DS-GETF #:G40 ':STORE))
;          (MATLISP:STORE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (OR MATLISP:STORE
;          (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STORE)
;            (VALUES MATLISP:STORE `#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY MATLISP:HEAD
;                                             &ALLOW-OTHER-KEYS)
;                                (ASSOC MATLISP::VEC MATLISP::DECL)))
;       (OR MATLISP:HEAD
;           (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:HEAD)
;             (VALUES MATLISP:HEAD `(#)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G27
;           (SB-C::CHECK-DS-LIST/&KEY #:G26 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                                   MATLISP:HEAD
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G27))
;          (TRIVIA.LEVEL2:PLACE (POP #:G27))
;          (#:G28 (SB-C::DS-GETF #:G27 ':HEAD))
;          (MATLISP:HEAD
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (OR MATLISP:HEAD
;          (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:HEAD)
;            (VALUES MATLISP:HEAD `#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY TYPE
;                                             &ALLOW-OTHER-KEYS)
;                                TRIVIA.LEVEL2:ALIST))
;       (IF (SUBTYPEP TYPE 'MATLISP:DENSE-TENSOR)
;           TYPE))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G15
;           (SB-C::CHECK-DS-LIST/&KEY #:G14 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY TYPE
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G15))
;          (TRIVIA.LEVEL2:PLACE (POP #:G15))
;          (#:G16 (SB-C::DS-GETF #:G15 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (IF (SUBTYPEP TYPE 'MATLISP:DENSE-TENSOR)
;          TYPE)))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/special/optimize.lisp
; in: DEFMACRO OPTIMIZE-EXPRESSION
;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                             MATLISP:STRIDES &ALLOW-OTHER-KEYS)
;                                (ASSOC MATLISP::VEC MATLISP::DECL)))
;       (OR MATLISP:STRIDES
;           (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STRIDES)
;             (VALUES MATLISP:STRIDES `(#)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G53
;           (SB-C::CHECK-DS-LIST/&KEY #:G52 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                                   MATLISP:STRIDES
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G53))
;          (TRIVIA.LEVEL2:PLACE (POP #:G53))
;          (#:G54 (SB-C::DS-GETF #:G53 ':STRIDES))
;          (MATLISP:STRIDES
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (OR MATLISP:STRIDES
;          (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STRIDES)
;            (VALUES MATLISP:STRIDES `#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                             MATLISP:STORE &ALLOW-OTHER-KEYS)
;                                (ASSOC MATLISP::VEC MATLISP::DECL)))
;       (OR MATLISP:STORE
;           (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STORE)
;             (VALUES MATLISP:STORE `(#)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G40
;           (SB-C::CHECK-DS-LIST/&KEY #:G39 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                                   MATLISP:STORE
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G40))
;          (TRIVIA.LEVEL2:PLACE (POP #:G40))
;          (#:G41 (SB-C::DS-GETF #:G40 ':STORE))
;          (MATLISP:STORE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (OR MATLISP:STORE
;          (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:STORE)
;            (VALUES MATLISP:STORE `#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY MATLISP:HEAD
;                                             &ALLOW-OTHER-KEYS)
;                                (ASSOC MATLISP::VEC MATLISP::DECL)))
;       (OR MATLISP:HEAD
;           (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:HEAD)
;             (VALUES MATLISP:HEAD `(#)))))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G27
;           (SB-C::CHECK-DS-LIST/&KEY #:G26 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY
;                                                   MATLISP:HEAD
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G27))
;          (TRIVIA.LEVEL2:PLACE (POP #:G27))
;          (#:G28 (SB-C::DS-GETF #:G27 ':HEAD))
;          (MATLISP:HEAD
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (OR MATLISP:HEAD
;          (ALEXANDRIA.0.DEV:WITH-GENSYMS (MATLISP:HEAD)
;            (VALUES MATLISP:HEAD `#)))))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.

;     (MATLISP-UTILITIES:LETV* (((MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY TYPE
;                                             &ALLOW-OTHER-KEYS)
;                                TRIVIA.LEVEL2:ALIST))
;       (IF (SUBTYPEP TYPE 'MATLISP:DENSE-TENSOR)
;           TYPE))
; --> LET DESTRUCTURING-BIND SB-INT:BINDING* 
; ==>
;   (LET* ((#:G15
;           (SB-C::CHECK-DS-LIST/&KEY #:G14 2 2
;                                     '(MATLISP:REF TRIVIA.LEVEL2:PLACE &KEY TYPE
;                                                   &ALLOW-OTHER-KEYS)
;                                     NIL))
;          (MATLISP:REF (POP #:G15))
;          (TRIVIA.LEVEL2:PLACE (POP #:G15))
;          (#:G16 (SB-C::DS-GETF #:G15 ':TYPE))
;          (TYPE
;           (IF (NOT #)
;               (CAR #))))
;     (LOCALLY
;      (IF (SUBTYPEP TYPE 'MATLISP:DENSE-TENSOR)
;          TYPE)))
; 
; caught STYLE-WARNING:
;   The variable REF is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable PLACE is defined but never used.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "special" "optimize">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/distributions/exponential.lisp
; in: EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
;     (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
;       (MATLISP-UTILITIES:DEFINLINE MATLISP::EXPONENTIAL-FUNCTION
;         (MATLISP::X)
;         (EXP (- MATLISP::X)))
;       (MATLISP-UTILITIES:DEFINLINE MATLISP::EXPONENTIAL-TAIL-SAMPLER
;         (MATLISP::R0 MATLISP::F0 IDENTITY)
;         (LET* ((MATLISP::U1 #))
;           (+ MATLISP::R0 (* -1 #)))))
; 
; caught STYLE-WARNING:
;   The variable F0 is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable IDENTITY is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/distributions/exponential.lisp
; in: DEFINLINE EXPONENTIAL-TAIL-SAMPLER
;     (MATLISP-UTILITIES:DEFINLINE MATLISP::EXPONENTIAL-TAIL-SAMPLER
;       (MATLISP::R0 MATLISP::F0 IDENTITY)
;       (LET* ((MATLISP::U1 (MATLISP:RANDOM-UNIFORM NIL T)))
;         (+ MATLISP::R0 (* -1 (LOG MATLISP::U1)))))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA MATLISP::EXPONENTIAL-TAIL-SAMPLER
;         (MATLISP::R0 MATLISP::F0 IDENTITY)
;       (BLOCK MATLISP::EXPONENTIAL-TAIL-SAMPLER
;         (LET* ((MATLISP::U1 #))
;           (+ MATLISP::R0 (* -1 #)))))
; 
; caught STYLE-WARNING:
;   The variable F0 is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable IDENTITY is defined but never used.
; in: CLOSER-MOP:DEFMETHOD (SETF REF)
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (MATLISP:STRIDES MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code
; in: CLOSER-MOP:DEFMETHOD REF
;     (MATLISP:DIMENSIONS MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

;     (MATLISP:STRIDES MATLISP::X)
; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF PROGN THE AREF MATLISP-UTILITIES:MODPROJ 
; --> MATLISP:ORDER BLOCK LENGTH THE SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; --> BLOCK TYPECASE LET COND IF IF THE PROGN MATLISP-UTILITIES:LVEC->LIST THE 
; --> SLOT-VALUE 
; ==>
;   MATLISP::X
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/distributions/exponential.lisp
; in: EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
;     (EVAL-WHEN (:COMPILE-TOPLEVEL :LOAD-TOPLEVEL :EXECUTE)
;       (MATLISP-UTILITIES:DEFINLINE MATLISP::GAUSSIAN-FUNCTION
;         (MATLISP::X)
;         (EXP (* -1/2 MATLISP::X MATLISP::X)))
;       (MATLISP-UTILITIES:DEFINLINE MATLISP::GAUSSIAN-TAIL-SAMPLER
;         (MATLISP::R0 MATLISP::F0 IDENTITY)
;         (LET* ((MATLISP::U1 #) (MATLISP::U2 #) (MATLISP::X #) (MATLISP::Y #))
;           (IF (> # #)
;               (+ MATLISP::X MATLISP::R0)))))
; 
; caught STYLE-WARNING:
;   The variable F0 is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable IDENTITY is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/distributions/exponential.lisp
; in: DEFINLINE GAUSSIAN-TAIL-SAMPLER
;     (MATLISP-UTILITIES:DEFINLINE MATLISP::GAUSSIAN-TAIL-SAMPLER
;       (MATLISP::R0 MATLISP::F0 IDENTITY)
;       (LET* ((MATLISP::U1 (MATLISP:RANDOM-UNIFORM NIL T))
;              (MATLISP::U2 (MATLISP:RANDOM-UNIFORM NIL T))
;              (MATLISP::X (* -1 # #))
;              (MATLISP::Y (- 1 #)))
;         (IF (> (+ MATLISP::Y MATLISP::Y) (* MATLISP::X MATLISP::X))
;             (+ MATLISP::X MATLISP::R0))))
; --> PROGN DEFUN PROGN SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA MATLISP::GAUSSIAN-TAIL-SAMPLER
;         (MATLISP::R0 MATLISP::F0 IDENTITY)
;       (BLOCK MATLISP::GAUSSIAN-TAIL-SAMPLER
;         (LET* ((MATLISP::U1 #) (MATLISP::U2 #) (MATLISP::X #) (MATLISP::Y #))
;           (IF (> # #)
;               (+ MATLISP::X MATLISP::R0)))))
; 
; caught STYLE-WARNING:
;   The variable F0 is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable IDENTITY is defined but never used.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/distributions/exponential.lisp
; in: DEFRANDOM RANDOM-BETA
;     (MATLISP:RANDOM-GAMMA MATLISP::B)
; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET IF * 
; ==>
;   MATLISP::B
; 
; note: deleting unreachable code

; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET COERCE 
; ==>
;   MATLISP::B
; 
; note: deleting unreachable code

; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET IF * * * 
; ==>
;   MATLISP::B
; 
; note: deleting unreachable code

;     (MATLISP:RANDOM-GAMMA MATLISP::A)
; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET IF * MATLISP::RANDOM-GAMMA-KERNEL 
; ==>
;   MATLISP::A
; 
; note: deleting unreachable code

; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET COERCE 
; ==>
;   MATLISP::A
; 
; note: deleting unreachable code

; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET IF < 
; ==>
;   MATLISP::A
; 
; note: deleting unreachable code

; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET IF * * * 
; --> MATLISP::RANDOM-GAMMA-KERNEL + 
; ==>
;   MATLISP::A
; 
; note: deleting unreachable code

; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET LET IF * * THE EXPT / / THE 
; ==>
;   MATLISP::A
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/src/distributions/exponential.lisp
; in: DEFUN RANDOM-T-KERNEL
;     (MATLISP:RANDOM-CHI-SQUARE MATLISP::NU)
; --> BLOCK IF LET MATLISP:DOREFS MATLISP-UTILITIES:LET-TYPED LET 
; --> MATLISP-UTILITIES:LET-TYPED LET ITERATE:ITER LET* BLOCK TAGBODY PROGN 
; --> SYMBOL-MACROLET SETQ SETF LET* LET * MATLISP:RANDOM-GAMMA / COERCE 
; ==>
;   MATLISP::NU
; 
; note: deleting unreachable code
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "matlisp" "src" "distributions" "exponential">
WARNING: System definition file #P"/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/matlisp.asd" contains definition for system "matlisp-tests". Please only define "matlisp" and secondary systems with a name starting with "matlisp/" (e.g. "matlisp/test") in that file.
WARNING: Computing just-done stamp in plan NIL for action (ASDF/LISP-ACTION:PREPARE-OP "matlisp-tests"), but dependency (ASDF/LISP-ACTION:LOAD-OP "matlisp") wasn't done yet!
Unhandled UNBOUND-VARIABLE in thread #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>: The variable SRANDN is unbound.

Backtrace for: #<SB-THREAD:THREAD "main thread" RUNNING {10006105B3}>
0: (SYMBOL-VALUE SRANDN)
1: (SB-FASL::LOAD-FASL-GROUP #S(SB-FASL::FASL-INPUT :STREAM #<SB-SYS:FD-STREAM for "file /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/t/utilities.fasl" {100422DEF3}> :TABLE #(8 SET *PACKAGE* "MATLISP-TESTS" #<PACKAGE "MATLISP"> MATLISP::GENERATE-RAND SYMBOL-VALUE #<PACKAGE "MATLISP-TESTS"> SRANDN 0 0 0 ...) :STACK #(1 MATLISP::GENERATE-RAND SYMBOL-VALUE SRANDN 0 0 0 0 0 0 0 0 ...) :NAME-BUFFER #("" "SRANDN-VALUED") :DEPRECATED-STUFF NIL :SKIP-UNTIL NIL) NIL)
2: (SB-FASL::LOAD-AS-FASL #<SB-SYS:FD-STREAM for "file /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/t/utilities.fasl" {100422DEF3}> NIL NIL)
3: ((FLET SB-FASL::THUNK :IN LOAD))
4: (SB-FASL::CALL-WITH-LOAD-BINDINGS #<CLOSURE (FLET SB-FASL::THUNK :IN LOAD) {7FFFF6DA698B}> #<SB-SYS:FD-STREAM for "file /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/t/utilities.fasl" {100422DEF3}>)
5: ((FLET SB-FASL::LOAD-STREAM :IN LOAD) #<SB-SYS:FD-STREAM for "file /home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/t/utilities.fasl" {100422DEF3}> T)
6: (LOAD #P"/home/quicklisp/.cache/common-lisp/sbcl-1.4.4-linux-x64/home/quicklisp/quicklisp-controller/dist/build-cache/matlisp/af93d6574fb1ab8c4038c951b8ea5de1e20c9c90/matlisp-20180225-git/t/utilities.fasl" :VERBOSE NIL :PRINT NIL :IF-DOES-NOT-EXIST T :EXTERNAL-FORMAT :DEFAULT)
7: (UIOP/UTILITY:CALL-WITH-MUFFLED-CONDITIONS #<CLOSURE (LAMBDA NIL :IN UIOP/LISP-BUILD:LOAD*) {100422BF3B}> ("Overwriting already existing readtable ~S." #(#:FINALIZERS-OFF-WARNING :ASDF-FINALIZERS)))
8: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "matlisp-tests" "t" "utilities">)
9: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
10: ((:METHOD ASDF/ACTION:PERFORM :AROUND (ASDF/LISP-ACTION:LOAD-OP ASDF/LISP-ACTION:CL-SOURCE-FILE)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "matlisp-tests" "t" "utilities">) [fast-method]
11: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS (ASDF/LISP-ACTION:LOAD-OP ASDF/LISP-ACTION:CL-SOURCE-FILE)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "matlisp-tests" "t" "utilities">) [fast-method]
12: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "matlisp-tests" "t" "utilities">) [fast-method]
13: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005D999C3}>) [fast-method]
14: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
15: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {1005D999C3}>) [fast-method]
16: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "matlisp-tests"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
17: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "matlisp-tests">)
18: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
19: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "matlisp-tests">) [fast-method]
20: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "matlisp-tests")
21: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
22: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "matlisp-tests") [fast-method]
23: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005D931EB}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
24: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
25: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<CLOSURE (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {1005D9077B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
26: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "matlisp-tests") [fast-method]
27: (DEPCHECK::COMPUTE-DEPENDENCIES "matlisp" "matlisp-tests")
28: (DEPCHECK::MAGIC "matlisp" "matlisp-tests" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-P41gBd6L/depcheck-win.txt")
29: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "matlisp" "matlisp-tests" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-P41gBd6L/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-P41gBd6L/depcheck-fail.txt"))
30: ((LAMBDA NIL :IN "/home/quicklisp/src/quicklisp-controller/dumper-2SKVI5f7.lisp"))
31: ((FLET SB-UNIX::BODY :IN SB-EXT:SAVE-LISP-AND-DIE))
32: ((FLET "WITHOUT-INTERRUPTS-BODY-36" :IN SB-EXT:SAVE-LISP-AND-DIE))
33: ((LABELS SB-IMPL::RESTART-LISP :IN SB-EXT:SAVE-LISP-AND-DIE))

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