numcl

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/jmt.lisp
; in: DEFUN MT-MAKE-RANDOM-STATE-RANDOM
;     (INCF RANDOM-DISTRIBUTIONS::SOME-NUMBER)
; --> THE 
; ==>
;   (+ 1 RANDOM-DISTRIBUTIONS::SOME-NUMBER)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (+ (GET-UNIVERSAL-TIME) (INCF RANDOM-DISTRIBUTIONS::SOME-NUMBER))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a (INTEGER 1), not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 1), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

; in: DEFUN MAKE-MT-RANDOM-STATE
;     (TYPEP RANDOM-DISTRIBUTIONS::STATE 'SEQUENCE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (AND (NOT INTEGER) (NOT BOOLEAN)), not a (NOT SB-KERNEL:EXTENDED-SEQUENCE).

;     (LENGTH RANDOM-DISTRIBUTIONS::STATE)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a VECTOR.

;     (FIND-IF #'INTEGERP RANDOM-DISTRIBUTIONS::STATE)
; 
; note: unable to optimize due to type uncertainty: The second argument is a (OR CONS VECTOR SB-KERNEL:EXTENDED-SEQUENCE), not a (OR LIST VECTOR).

; in: DEFUN RANDOM-MT
;     (ASSERT (PLUSP RANDOM-DISTRIBUTIONS::N))
; --> LET WHEN IF PLUSP 
; ==>
;   1
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (+ 32 RANDOM-DISTRIBUTIONS::BIT-COUNT)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 32 32) (INTEGER 64 64) (INTEGER 96 96) (INTEGER 128 128) (INTEGER 160 160) (INTEGER 192)), not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER 32 32) (INTEGER 64 64) (INTEGER 96 96) (INTEGER 128 128) (INTEGER 160 160) (INTEGER 192)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER 0 0) (INTEGER 32 32) (INTEGER 64 64) (INTEGER 96 96) (INTEGER 128 128) (INTEGER 160 160) (INTEGER 192)), not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER 32 32) (INTEGER 64 64) (INTEGER 96 96) (INTEGER 128 128) (INTEGER 160 160) (INTEGER 192)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (ASH RANDOM-DISTRIBUTIONS::R 32)
; 
; note: forced to do full call
;       unable to do inline ASH (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -4294967296) (INTEGER 0 0) (INTEGER 4294967296)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline ASH (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES (OR (INTEGER * -4294967296) (INTEGER 0 0) (INTEGER 4294967296)) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (+ (ASH RANDOM-DISTRIBUTIONS::R 32) (RANDOM-DISTRIBUTIONS::MT-GENRAND))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (OR (INTEGER * -4294967296) (INTEGER 0 0) (INTEGER 4294967296)), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (OR (INTEGER * -4294967296) (INTEGER 0 0) (INTEGER 4294967296)), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* (RANDOM-DISTRIBUTIONS::MT-GENRAND)
;        RANDOM-DISTRIBUTIONS::+MT-K-INVERSE-2^32F+ RANDOM-DISTRIBUTIONS::N)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (REAL (0)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/normal.lisp
; in: DEFUN RANDOM-NORMAL-ZIGGURAT
;     (EXP
;      (-
;       (* RANDOM-DISTRIBUTIONS::+R+
;          (- RANDOM-DISTRIBUTIONS::X (/ RANDOM-DISTRIBUTIONS::+R+ 2)))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::U1)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (EXP (- (/ (* RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::X) 2)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (LOG RANDOM-DISTRIBUTIONS::U1)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (EXP
;      (-
;       (* RANDOM-DISTRIBUTIONS::+R+
;          (- RANDOM-DISTRIBUTIONS::X (/ RANDOM-DISTRIBUTIONS::+R+ 2)))))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN RANDOM-NORMAL
;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-NORMAL
;            (
;             &OPTIONAL (RANDOM-DISTRIBUTIONS::MEAN 0.0d0)
;             (RANDOM-DISTRIBUTIONS::SIGMA 1.0d0))
;       "Generate random variable with normal distribution using ziggurat method"
;       (RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-ZIGGURAT
;        (COERCE RANDOM-DISTRIBUTIONS::MEAN 'DOUBLE-FLOAT)
;        (COERCE RANDOM-DISTRIBUTIONS::SIGMA 'DOUBLE-FLOAT)))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-NORMAL
;         (&OPTIONAL (RANDOM-DISTRIBUTIONS::MEAN 0.0d0)
;          (RANDOM-DISTRIBUTIONS::SIGMA 1.0d0))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Generate random variable with normal distribution using ziggurat method"
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-NORMAL
;         (RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-ZIGGURAT
;          (COERCE RANDOM-DISTRIBUTIONS::MEAN 'DOUBLE-FLOAT)
;          (COERCE RANDOM-DISTRIBUTIONS::SIGMA 'DOUBLE-FLOAT))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; in: DEFUN RANDOM-NORMAL-BIVARIATE
;     (LOG RANDOM-DISTRIBUTIONS::RADIUS)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;            (RANDOM-DISTRIBUTIONS::SIGMA-X RANDOM-DISTRIBUTIONS::SIGMA-Y
;             &KEY (RANDOM-DISTRIBUTIONS::RHO 0.0d0)
;             (RANDOM-DISTRIBUTIONS::ERROR-LIMIT 500))
;       #<(SIMPLE-ARRAY CHARACTER
;          (807)) Return a pair of numbers with specific correlation coefficent rho
;   and with specified variances sigma-x and sigma-y; a direct port of
;   gsl_ran_bivariate_gaussian from the GNU Scientific Library:
;   
;   void
;   g... {120934BE4F}>
;       (LET ((RANDOM-DISTRIBUTIONS::STATE *RANDOM-STATE*))
;         (LOOP RANDOM-DISTRIBUTIONS::REPEAT RANDOM-DISTRIBUTIONS::ERROR-LIMIT
;               DO (LET* (# # #)
;                    (WHEN # #))
;               RANDOM-DISTRIBUTIONS::FINALLY (ERROR
;                                              "Unsuccessful ~S after ~S tries."
;                                              'RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;                                              RANDOM-DISTRIBUTIONS::ERROR-LIMIT))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;         (RANDOM-DISTRIBUTIONS::SIGMA-X RANDOM-DISTRIBUTIONS::SIGMA-Y &KEY
;          (RANDOM-DISTRIBUTIONS::RHO 0.0d0)
;          (RANDOM-DISTRIBUTIONS::ERROR-LIMIT 500))
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       #<(SIMPLE-ARRAY CHARACTER
;          (807)) Return a pair of numbers with specific correlation coefficent rho
; and with specified variances sigma-x and sigma-y; a direct port of
; gsl_ran_bivariate_gaussian from the GNU Scientific Library:
; 
; void
; g... {120934BE4F}>
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;         (LET ((RANDOM-DISTRIBUTIONS::STATE *RANDOM-STATE*))
;           (LOOP RANDOM-DISTRIBUTIONS::REPEAT RANDOM-DISTRIBUTIONS::ERROR-LIMIT
;                 DO (LET* #
;                      #)
;                 RANDOM-DISTRIBUTIONS::FINALLY (ERROR
;                                                "Unsuccessful ~S after ~S tries."
;                                                'RANDOM-DISTRIBUTIONS:RANDOM-NORMAL-BIVARIATE
;                                                RANDOM-DISTRIBUTIONS::ERROR-LIMIT)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/gamma.lisp
; in: DEFUN GAMMA-LARGE
;     (SQRT (- (* 2 RANDOM-DISTRIBUTIONS::A) 1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (TAN (* PI (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (EXP
;      (- (* RANDOM-DISTRIBUTIONS::A-1 (THE DOUBLE-FLOAT (LOG #)))
;         (* RANDOM-DISTRIBUTIONS::SQA RANDOM-DISTRIBUTIONS::Y)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (SQRT (- (* 2 RANDOM-DISTRIBUTIONS::A) 1))
; 
; note: doing float to pointer coercion (cost 13)

;     (TAN (* PI (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (LOG (/ RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::A-1))
; 
; note: doing float to pointer coercion (cost 13)

;     (EXP
;      (- (* RANDOM-DISTRIBUTIONS::A-1 (THE DOUBLE-FLOAT (LOG #)))
;         (* RANDOM-DISTRIBUTIONS::SQA RANDOM-DISTRIBUTIONS::Y)))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS::GAMMA-LARGE (RANDOM-DISTRIBUTIONS::A)
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A))
;       (LET* ((RANDOM-DISTRIBUTIONS::A-1 (- RANDOM-DISTRIBUTIONS::A 1.0d0))
;              (RANDOM-DISTRIBUTIONS::SQA (SQRT #))
;              (RANDOM-DISTRIBUTIONS::X 0.0d0)
;              (RANDOM-DISTRIBUTIONS::Y 0.0d0)
;              (RANDOM-DISTRIBUTIONS::V 0.0d0))
;         (DECLARE
;          (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::X
;           RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V
;           RANDOM-DISTRIBUTIONS::SQA)
;          (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::SQA
;           RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V))
;         (TAGBODY
;          RANDOM-DISTRIBUTIONS::START
;           (SETQ RANDOM-DISTRIBUTIONS::Y #)
;           (SETQ RANDOM-DISTRIBUTIONS::X #)
;           (WHEN (<= RANDOM-DISTRIBUTIONS::X 0.0)
;             (GO RANDOM-DISTRIBUTIONS::START))
;           (SETQ RANDOM-DISTRIBUTIONS::V #)
;           (WHEN (> RANDOM-DISTRIBUTIONS::V #) (GO RANDOM-DISTRIBUTIONS::START)))
;         RANDOM-DISTRIBUTIONS::X))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;         (RANDOM-DISTRIBUTIONS::A)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A))
;       (BLOCK RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;         (LET* ((RANDOM-DISTRIBUTIONS::A-1 #)
;                (RANDOM-DISTRIBUTIONS::SQA #)
;                (RANDOM-DISTRIBUTIONS::X 0.0d0)
;                (RANDOM-DISTRIBUTIONS::Y 0.0d0)
;                (RANDOM-DISTRIBUTIONS::V 0.0d0))
;           (DECLARE
;            (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::X
;             RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V
;             RANDOM-DISTRIBUTIONS::SQA)
;            (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::A-1 RANDOM-DISTRIBUTIONS::SQA
;             RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::V))
;           (TAGBODY
;            RANDOM-DISTRIBUTIONS::START
;             (SETQ #)
;             (SETQ #)
;             (WHEN # #)
;             (SETQ #)
;             (WHEN # #))
;           RANDOM-DISTRIBUTIONS::X)))
; 
; note: doing float to pointer coercion (cost 13) from X to "<return value>"

; in: DEFUN RANDOM-GAMMA-INT
;     (RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;      (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT))
; --> BLOCK LET* TAGBODY SETQ THE TAN 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::PROD)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;      (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT))
; --> BLOCK LET* TAGBODY WHEN IF > * EXP - * THE LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET* TAGBODY WHEN IF > * EXP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET* TAGBODY SETQ THE TAN 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET* TAGBODY WHEN IF > * EXP - * THE LOG 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET* TAGBODY WHEN IF > * EXP 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT (RANDOM-DISTRIBUTIONS::A)
;       "Random variable with gamma distribution with integer parameter."
;       (DECLARE (FIXNUM RANDOM-DISTRIBUTIONS::A))
;       (IF (< RANDOM-DISTRIBUTIONS::A 12)
;           (DO ((RANDOM-DISTRIBUTIONS::I 0 #)
;                (RANDOM-DISTRIBUTIONS::PROD 1.0d0 #))
;               ((= RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::A) (- #))
;             (DECLARE (FIXNUM RANDOM-DISTRIBUTIONS::I)
;                      (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::PROD)))
;           (RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;            (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT
;         (RANDOM-DISTRIBUTIONS::A)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Random variable with gamma distribution with integer parameter."
;       (DECLARE (FIXNUM RANDOM-DISTRIBUTIONS::A))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT
;         (IF (< RANDOM-DISTRIBUTIONS::A 12)
;             (DO (#
;                  #)
;                 (# #)
;               (DECLARE #
;                        #))
;             (RANDOM-DISTRIBUTIONS::GAMMA-LARGE
;              (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

;     (LOG RANDOM-DISTRIBUTIONS::PROD)
; 
; note: doing float to pointer coercion (cost 13) from PROD
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; in: DEFUN GAMMA-FRAC
;     (LOG RANDOM-DISTRIBUTIONS::V)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (EXP (* (- RANDOM-DISTRIBUTIONS::A 1.0d0) (LOG RANDOM-DISTRIBUTIONS::X)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::V)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (EXP (* (/ 1.0d0 RANDOM-DISTRIBUTIONS::A) (LOG RANDOM-DISTRIBUTIONS::V)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (EXP (- RANDOM-DISTRIBUTIONS::X))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (RANDOM-DISTRIBUTIONS::RANDOM-POS)
; --> BLOCK LOOP BLOCK TAGBODY PROGN LET RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM 
; --> BLOCK RANDOM 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

;     (LOG RANDOM-DISTRIBUTIONS::V)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

;     (EXP (* (/ 1.0d0 RANDOM-DISTRIBUTIONS::A) (LOG RANDOM-DISTRIBUTIONS::V)))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (EXP (- RANDOM-DISTRIBUTIONS::X))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (LOG RANDOM-DISTRIBUTIONS::V)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

;     (SETF RANDOM-DISTRIBUTIONS::X (- 1.0d0 (LOG RANDOM-DISTRIBUTIONS::V)))
; 
; note: doing float to pointer coercion (cost 13) to X

;     (LOG RANDOM-DISTRIBUTIONS::X)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

;     (EXP (* (- RANDOM-DISTRIBUTIONS::A 1.0d0) (LOG RANDOM-DISTRIBUTIONS::X)))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; in: DEFUN RANDOM-GAMMA1
;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::FRAC)
; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::A)
; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

; --> BLOCK LET TAGBODY SETF SETQ THE RANDOM-DISTRIBUTIONS::RANDOM-POS BLOCK 
; --> LOOP BLOCK TAGBODY PROGN LET RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM BLOCK 
; --> RANDOM 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-GAMMA1
;            (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       #<(SIMPLE-ARRAY CHARACTER
;          (576)) The Gamma distribution of order a>0 is defined by:
;   
;     p(x) dx = {1 / Gamma(a) b^a } x^{a-1} e^{-x/b} dx
;   
;     for x>0.  If X and Y are independent gamma-distributed random
;     variables of order a1 and a2 ... {120A22719F}>
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (ASSERT (> RANDOM-DISTRIBUTIONS::A 0.0d0))
;       (MULTIPLE-VALUE-BIND (RANDOM-DISTRIBUTIONS::NA RANDOM-DISTRIBUTIONS::FRAC)
;           (TRUNCATE RANDOM-DISTRIBUTIONS::A)
;         (DECLARE
;          (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::NA RANDOM-DISTRIBUTIONS::FRAC))
;         (IF (= RANDOM-DISTRIBUTIONS::FRAC 0)
;             (* RANDOM-DISTRIBUTIONS::B
;                (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA))
;             (IF (= RANDOM-DISTRIBUTIONS::NA 0)
;                 (* RANDOM-DISTRIBUTIONS::B #)
;                 (* RANDOM-DISTRIBUTIONS::B #)))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-GAMMA1
;         (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       #<(SIMPLE-ARRAY CHARACTER
;          (576)) The Gamma distribution of order a>0 is defined by:
; 
;   p(x) dx = {1 / Gamma(a) b^a } x^{a-1} e^{-x/b} dx
; 
;   for x>0.  If X and Y are independent gamma-distributed random
;   variables of order a1 and a2 ... {120A22719F}>
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-GAMMA1
;         (ASSERT (> RANDOM-DISTRIBUTIONS::A 0.0d0))
;         (MULTIPLE-VALUE-BIND
;             (RANDOM-DISTRIBUTIONS::NA RANDOM-DISTRIBUTIONS::FRAC)
;             (TRUNCATE RANDOM-DISTRIBUTIONS::A)
;           (DECLARE
;            (DYNAMIC-EXTENT RANDOM-DISTRIBUTIONS::NA
;             RANDOM-DISTRIBUTIONS::FRAC))
;           (IF (= RANDOM-DISTRIBUTIONS::FRAC 0)
;               (* RANDOM-DISTRIBUTIONS::B #)
;               (IF #
;                   #
;                   #)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::A)
; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   RANDOM-DISTRIBUTIONS::X
; 
; note: doing float to pointer coercion (cost 13) from X

; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE LOG 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS::GAMMA-FRAC RANDOM-DISTRIBUTIONS::FRAC)
; --> BLOCK LET TAGBODY SETF SETQ THE RANDOM-DISTRIBUTIONS::RANDOM-POS BLOCK 
; --> LOOP BLOCK TAGBODY PROGN LET RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM BLOCK 
; --> RANDOM 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE - LOG 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP * LOG 
; ==>
;   RANDOM-DISTRIBUTIONS::X
; 
; note: doing float to pointer coercion (cost 13) from X

; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; --> BLOCK LET TAGBODY IF PROGN SETF SETQ THE EXP 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-INT RANDOM-DISTRIBUTIONS::NA)
; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13) from PROD
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY SETQ THE 
; --> TAN 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP - * THE LOG 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF RANDOM-DISTRIBUTIONS::GAMMA-LARGE BLOCK LET* TAGBODY WHEN IF > * 
; --> EXP 
; ==>
;   1
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; --> BLOCK IF DO BLOCK LET TAGBODY RETURN-FROM PROGN - 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13) from PROD
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

; in: DEFUN RANDOM-GAMMA-MT
;     (EXPT (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM) (/ RANDOM-DISTRIBUTIONS::A))
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::U)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::V)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SB-ALIEN-INTERNALS:ALIEN-VALUE, not a (SB-ALIEN:ALIEN (* T)).
; 
; note: unable to optimize because: can't tell function type at compile time

;     (LOG RANDOM-DISTRIBUTIONS::U)
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

;     (LOG RANDOM-DISTRIBUTIONS::V)
; 
; note: doing float to pointer coercion (cost 13) from V
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT

;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT
;            (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       "New version based on Marsaglia and Tsang, 'A Simple Method for
;   generating gamma variables', ACM Transactions on Mathematical
;   Software, Vol 26, No 3 (2000), p363-372."
;       (DECLARE (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (IF (< RANDOM-DISTRIBUTIONS::A 1.0d0)
;           (*
;            (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA-MT
;             (+ 1.0d0 RANDOM-DISTRIBUTIONS::A) RANDOM-DISTRIBUTIONS::B)
;            (EXPT (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)
;                  (/ RANDOM-DISTRIBUTIONS::A)))
;           (LET* ((RANDOM-DISTRIBUTIONS::X 0.0d0)
;                  (RANDOM-DISTRIBUTIONS::V 0.0d0)
;                  (RANDOM-DISTRIBUTIONS::U 0.0d0)
;                  (RANDOM-DISTRIBUTIONS::D #)
;                  (RANDOM-DISTRIBUTIONS::C #))
;             (DECLARE
;              (DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::X RANDOM-DISTRIBUTIONS::V
;               RANDOM-DISTRIBUTIONS::U RANDOM-DISTRIBUTIONS::D
;               RANDOM-DISTRIBUTIONS::C))
;             (TAGBODY
;              RANDOM-DISTRIBUTIONS::START
;               (SETF #)
;               (SETF #)
;               (WHEN # #)
;               (SETF #)
;               (SETF #)
;               (WHEN # #)
;               (WHEN # #)
;               (GO RANDOM-DISTRIBUTIONS::START)
;              RANDOM-DISTRIBUTIONS::END)
;             (* RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::D
;                RANDOM-DISTRIBUTIONS::V))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

;     (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)
; --> BLOCK RANDOM 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13)

;     (EXPT (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM) (/ RANDOM-DISTRIBUTIONS::A))
; 
; note: doing SAP to pointer coercion (cost 20), for:
;       the second argument of SET-SLOT
; 
; note: doing float to pointer coercion (cost 13)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/binomial.lisp
; in: DEFUN RANDOM-BINOMIAL
;     (<= RANDOM-DISTRIBUTIONS::N 10)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (+ 1 (FLOOR RANDOM-DISTRIBUTIONS::N 2))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 5), not a FIXNUM.
;       The result is a (VALUES (INTEGER 6) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 5), not a FIXNUM.
;       The result is a (VALUES (INTEGER 6) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 11), not a FIXNUM.
;       The second argument is a (INTEGER 6), not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 11), not a (UNSIGNED-BYTE 64).
;       The second argument is a (INTEGER 6), not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (+ 1 (- RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::A))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (COERCE RANDOM-DISTRIBUTIONS::A 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (INTEGER 4611686018427387904), not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::B 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a BIGNUM, not a (SIGNED-BYTE 64).

;     (INCF RANDOM-DISTRIBUTIONS::K RANDOM-DISTRIBUTIONS::A)
; --> THE 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 6), not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a (INTEGER 6), not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::B 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::A 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER 6), not a FIXNUM.
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER 6), not a FIXNUM.
;       The result is a (VALUES (INTEGER 5) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::N 1)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (INTEGER * 10), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 9) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a (INTEGER * 10), not a FIXNUM.
;       The result is a (VALUES (INTEGER * 9) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (INCF RANDOM-DISTRIBUTIONS::K)
; --> THE 
; ==>
;   (+ 1 RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/poisson.lisp
; in: DEFUN RANDOM-POISSON
;     (+ RANDOM-DISTRIBUTIONS::K
;        (TRUNCATE
;         (RANDOM-DISTRIBUTIONS:RANDOM-BINOMIAL
;          (/ RANDOM-DISTRIBUTIONS::MU RANDOM-DISTRIBUTIONS::X)
;          (- RANDOM-DISTRIBUTIONS::M 1))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (INCF RANDOM-DISTRIBUTIONS::K RANDOM-DISTRIBUTIONS::M)
; --> THE 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The second argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The second argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (INCF RANDOM-DISTRIBUTIONS::K)
; --> THE 
; ==>
;   (+ 1 RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (1- RANDOM-DISTRIBUTIONS::K)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The result is a (VALUES INTEGER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/nbinomial.lisp
; in: DEFUN RANDOM-NEGATIVE-BINOMIAL
;     (RANDOM-DISTRIBUTIONS:RANDOM-POISSON RANDOM-DISTRIBUTIONS::MU)
; 
; note: Type assertion too complex to check efficiently:
; (VALUES INTEGER &REST T).
; It allows an unknown number of values, consider using
; (VALUES INTEGER &OPTIONAL).

;     (COERCE RANDOM-DISTRIBUTIONS::N 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a BIGNUM, not a (SIGNED-BYTE 64).

;     (FORMAT T "NBIN: mu=~a~%" RANDOM-DISTRIBUTIONS::MU)
; 
; note: doing float to pointer coercion (cost 13)

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/multinomial.lisp
; in: DEFUN RANDOM-MULTINOMIAL1
;     (ARRAY-DIMENSION RANDOM-DISTRIBUTIONS::P 0)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

;     (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (> (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I) 0.0d0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (/ (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
;        (- RANDOM-DISTRIBUTIONS::NORM RANDOM-DISTRIBUTIONS::SUM-P))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::I)
; --> FUNCALL 
; ==>
;   1
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::I)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I FIXNUM RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO RANDOM-DISTRIBUTIONS::K
;           RANDOM-DISTRIBUTIONS::SUM (AREF RANDOM-DISTRIBUTIONS::P
;                                           RANDOM-DISTRIBUTIONS::I))
; --> LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ THE 
; ==>
;   (+ #:SUM1 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (> (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I) 0.0d0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a T, not a DOUBLE-FLOAT.

;     (- RANDOM-DISTRIBUTIONS::NORM RANDOM-DISTRIBUTIONS::SUM-P)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (/ (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I)
;        (- RANDOM-DISTRIBUTIONS::NORM RANDOM-DISTRIBUTIONS::SUM-P))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::NN RANDOM-DISTRIBUTIONS::SUM-N)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a INTEGER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO RANDOM-DISTRIBUTIONS::K
;           DO (PROGN
;               (SETF (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::I)
;                       (IF #
;                           #
;                           0)))
;           RANDOM-DISTRIBUTIONS::SUM (AREF RANDOM-DISTRIBUTIONS::P
;                                           RANDOM-DISTRIBUTIONS::I) RANDOM-DISTRIBUTIONS::INTO ...)
; --> LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-SUM-COUNT LET TAGBODY SETQ 
; --> THE 
; ==>
;   (+ RANDOM-DISTRIBUTIONS::SUM-P
;      (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

; ==>
;   (+ RANDOM-DISTRIBUTIONS::SUM-N
;      (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::I))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

; in: DEFUN CONVERT-TO-DOUBLE-FLOAT-VECTOR
;     (MAP 'VECTOR
;          (LAMBDA (RANDOM-DISTRIBUTIONS::X)
;            (COERCE RANDOM-DISTRIBUTIONS::X 'DOUBLE-FLOAT))
;          RANDOM-DISTRIBUTIONS::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a SEQUENCE, not a VECTOR.

;     (COERCE RANDOM-DISTRIBUTIONS::X 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).

;     (LAMBDA (RANDOM-DISTRIBUTIONS::X)
;       (COERCE RANDOM-DISTRIBUTIONS::X 'DOUBLE-FLOAT))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; in: DEFUN RANDOM-MULTINOMIAL%
;     (ARRAY-DIMENSION RANDOM-DISTRIBUTIONS::P 0)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

; in: DEFUN TEST-MULTINOMIAL1
;     (ARRAY-DIMENSION RANDOM-DISTRIBUTIONS::P 0)
; 
; note: unable to optimize because: The array dimensions are unknown; must call ARRAY-DIMENSION at runtime.

;     (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.
; 
; note: unable to avoid runtime dispatch on array element type because: Upgraded element type of array is not known at compile time.
; 
; note: unable to optimize due to type uncertainty: The first argument is a VECTOR, not a SIMPLE-ARRAY.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO RANDOM-DISTRIBUTIONS::K
;           DO (PROGN
;               (RANDOM-DISTRIBUTIONS::RANDOM-MULTINOMIAL1 RANDOM-DISTRIBUTIONS::NN
;                RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::N)
;               (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::J RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO (1-
;                                                                                                                              RANDOM-DISTRIBUTIONS::D)
;                     DO (PUSH
;                         (AREF RANDOM-DISTRIBUTIONS::N RANDOM-DISTRIBUTIONS::J)
;                         (AREF RANDOM-DISTRIBUTIONS::R RANDOM-DISTRIBUTIONS::J)))))
; --> LET TAGBODY WHEN IF 
; ==>
;   (> RANDOM-DISTRIBUTIONS::I #:LIM0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.

; --> LET TAGBODY SB-LOOP::LOOP-DESETQ SETQ THE 1+ 
; ==>
;   1
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a UNSIGNED-BYTE, not a FIXNUM.
;       The result is a (VALUES (INTEGER 1) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       etc.

;     (FLOAT
;      (RANDOM-DISTRIBUTIONS::MEAN
;       (AREF RANDOM-DISTRIBUTIONS::R RANDOM-DISTRIBUTIONS::J)))
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a RATIONAL, not a (SIGNED-BYTE 64).

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (FLOAT
;      (RANDOM-DISTRIBUTIONS::VAR
;       (AREF RANDOM-DISTRIBUTIONS::R RANDOM-DISTRIBUTIONS::J)))
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a RATIONAL, not a (SIGNED-BYTE 64).

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)
;        (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a T, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a T, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* RANDOM-DISTRIBUTIONS::NN
;        (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)
;        (- 1.0d0 (AREF RANDOM-DISTRIBUTIONS::P RANDOM-DISTRIBUTIONS::J)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/exponential.lisp
; in: DEFUN RANDOM-EXPONENTIAL
;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-EXPONENTIAL (RANDOM-DISTRIBUTIONS::MU)
;       "Random values for:
;   p(x) dx = exp(-x/mu) dx/mu"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::MU))
;       (* (- RANDOM-DISTRIBUTIONS::MU)
;          (LOG (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-EXPONENTIAL
;         (RANDOM-DISTRIBUTIONS::MU)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Random values for:
; p(x) dx = exp(-x/mu) dx/mu"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::MU))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-EXPONENTIAL
;         (* (- RANDOM-DISTRIBUTIONS::MU)
;            (LOG (RANDOM-DISTRIBUTIONS:RANDOM-UNIFORM)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/f.lisp
; in: DEFUN RANDOM-F
;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-F
;            (RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2)
;       "Random value for:
;   
;   p(x) dx = (nu1^(nu1/2) nu2^(nu2/2) Gamma((nu1 + nu2)/2) /
;   Gamma(nu1/2) Gamma(nu2/2)) *
;   x^(nu1/2 - 1) (nu2 + nu1 * x)^(-nu1/2 -nu2/2) dx"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2))
;       (LET ((RANDOM-DISTRIBUTIONS::Y1
;              (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA # 2.0d0))
;             (RANDOM-DISTRIBUTIONS::Y2
;              (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA # 2.0d0)))
;         (DECLARE
;          (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::Y1 RANDOM-DISTRIBUTIONS::Y2))
;         (/ (* RANDOM-DISTRIBUTIONS::Y1 RANDOM-DISTRIBUTIONS::NU2)
;            (* RANDOM-DISTRIBUTIONS::Y2 RANDOM-DISTRIBUTIONS::NU1))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-F
;         (RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Random value for:
; 
; p(x) dx = (nu1^(nu1/2) nu2^(nu2/2) Gamma((nu1 + nu2)/2) /
; Gamma(nu1/2) Gamma(nu2/2)) *
; x^(nu1/2 - 1) (nu2 + nu1 * x)^(-nu1/2 -nu2/2) dx"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU1 RANDOM-DISTRIBUTIONS::NU2))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-F
;         (LET ((RANDOM-DISTRIBUTIONS::Y1 #) (RANDOM-DISTRIBUTIONS::Y2 #))
;           (DECLARE
;            (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::Y1
;             RANDOM-DISTRIBUTIONS::Y2))
;           (/ (* RANDOM-DISTRIBUTIONS::Y1 RANDOM-DISTRIBUTIONS::NU2)
;              (* RANDOM-DISTRIBUTIONS::Y2 RANDOM-DISTRIBUTIONS::NU1)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/pareto.lisp
; in: DEFUN RANDOM-PARETO
;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-PARETO
;            (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       "Random value for parato distribution:
;   p(x) dx = (a/b) / (x/b)^(a+1) dx     for x >= b"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (LET* ((RANDOM-DISTRIBUTIONS::X (RANDOM-DISTRIBUTIONS::RANDOM-POS))
;              (RANDOM-DISTRIBUTIONS::Z (EXPT RANDOM-DISTRIBUTIONS::X #)))
;         (* RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::Z)))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-PARETO
;         (RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Random value for parato distribution:
; p(x) dx = (a/b) / (x/b)^(a+1) dx     for x >= b"
;       (DECLARE
;        (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-PARETO
;         (LET* ((RANDOM-DISTRIBUTIONS::X #) (RANDOM-DISTRIBUTIONS::Z #))
;           (* RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::Z))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/chisq.lisp
; in: DEFUN RANDOM-CHI-SQUARE
;     (DEFUN RANDOM-DISTRIBUTIONS:RANDOM-CHI-SQUARE (RANDOM-DISTRIBUTIONS::NU)
;       "Generate random variable for chi square distribution:
;   
;   p(x) dx = (1/(2*Gamma(nu/2))) (x/2)^(nu/2 - 1) exp(-x/2) dx"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU))
;       (* 2.0d0
;          (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA (/ RANDOM-DISTRIBUTIONS::NU 2.0d0))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA RANDOM-DISTRIBUTIONS:RANDOM-CHI-SQUARE
;         (RANDOM-DISTRIBUTIONS::NU)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Generate random variable for chi square distribution:
; 
; p(x) dx = (1/(2*Gamma(nu/2))) (x/2)^(nu/2 - 1) exp(-x/2) dx"
;       (DECLARE (TYPE DOUBLE-FLOAT RANDOM-DISTRIBUTIONS::NU))
;       (BLOCK RANDOM-DISTRIBUTIONS:RANDOM-CHI-SQUARE
;         (* 2.0d0
;            (RANDOM-DISTRIBUTIONS:RANDOM-GAMMA
;             (/ RANDOM-DISTRIBUTIONS::NU 2.0d0)))))
; 
; note: doing float to pointer coercion (cost 13) to "<return value>"

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/desc-stat.lisp
; in: DEFMACRO VAR
;     (DEFMACRO RANDOM-DISTRIBUTIONS::VAR (&REST RANDOM-DISTRIBUTIONS::ARGS)
;       `(RANDOM-DISTRIBUTIONS::VARIANCE ,@RANDOM-DISTRIBUTIONS::ARGS))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%DEFMACRO 'RANDOM-DISTRIBUTIONS::VAR
;                    (SB-INT:NAMED-LAMBDA (MACRO-FUNCTION
;                                          RANDOM-DISTRIBUTIONS::VAR)
;                        (#:EXPR #:ENV)
;                      (DECLARE
;                       (SB-C::LAMBDA-LIST (&REST RANDOM-DISTRIBUTIONS::ARGS)))
;                      (DECLARE (IGNORE #:ENV))
;                      (SB-INT:NAMED-DS-BIND (:MACRO RANDOM-DISTRIBUTIONS::VAR
;                                             . DEFMACRO)
;                          (&REST RANDOM-DISTRIBUTIONS::ARGS)
;                          (CDR #:EXPR)
;                        (DECLARE
;                         (SB-C::CONSTANT-VALUE RANDOM-DISTRIBUTIONS::ARGS))
;                        (BLOCK RANDOM-DISTRIBUTIONS::VAR
;                          `(RANDOM-DISTRIBUTIONS::VARIANCE
;                            ,@RANDOM-DISTRIBUTIONS::ARGS))))
;                    (SB-C:SOURCE-LOCATION))
; 
; caught STYLE-WARNING:
;   VAR is being redefined as a macro when it was previously assumed to be a function.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "cl-randist" "desc-stat">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/cl-randist/d26242a1b0e076ce3806415afecd009348ee3c57/cl-randist-20250831-git/GIG.lisp
; in: DEFUN TRANSFER-SIGN
;     (>= RANDOM-DISTRIBUTIONS::B 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (ABS RANDOM-DISTRIBUTIONS::A)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (- (ABS RANDOM-DISTRIBUTIONS::A))
; 
; note: unable to Eliminate %negate/%negate of rationals due to type uncertainty: The first argument is a (REAL 0), not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::A)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (- (ABS RANDOM-DISTRIBUTIONS::A))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline fixnum arithmetic (cost 1) because:
;       The first argument is a (REAL 0), not a FIXNUM.
;       The result is a (VALUES (REAL * 0) &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL * 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

; in: DEFUN ZEROIN
;     (FUNCALL RANDOM-DISTRIBUTIONS::FUN RANDOM-DISTRIBUTIONS::A)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUN is not known to be a function

;     (FUNCALL RANDOM-DISTRIBUTIONS::FUN RANDOM-DISTRIBUTIONS::B)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUN is not known to be a function

;     (ABS RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::FB)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (>= (ABS RANDOM-DISTRIBUTIONS::FC) (ABS RANDOM-DISTRIBUTIONS::FB))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.The second argument is a (REAL 0), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.The second argument is a (REAL 0), not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::B)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::XM)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).

;     (= RANDOM-DISTRIBUTIONS::FB 0.0d0)
; 
; note: unable to open code because: The operands might not be the same type.
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::E)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::FA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (ABS RANDOM-DISTRIBUTIONS::FB)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (<= (ABS RANDOM-DISTRIBUTIONS::FA) (ABS RANDOM-DISTRIBUTIONS::FB))
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a SINGLE-FLOAT.The second argument is a (REAL 0), not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a (REAL 0), not a DOUBLE-FLOAT.The second argument is a (REAL 0), not a RATIONAL.

;     (= RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::C)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a SINGLE-FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a DOUBLE-FLOAT.The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The second argument is a NUMBER, not a RATIONAL.
; 
; note: unable to open code because: The operands might not be the same type.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::S)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (/ RANDOM-DISTRIBUTIONS::FA RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).

;     (ABS (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).

;     (ABS RANDOM-DISTRIBUTIONS::D)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (FUNCALL RANDOM-DISTRIBUTIONS::FUN RANDOM-DISTRIBUTIONS::B)
; 
; note: unable to optimize away possible call to FDEFINITION at runtime because: FUN is not known to be a function

;     (ABS RANDOM-DISTRIBUTIONS::FC)
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &REST T).
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a RATIONAL.

;     (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC))
; 
; note: unable to optimize due to type uncertainty: The first argument is a NUMBER, not a INTEGER.The second argument is a (REAL 0), not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (>
;      (* RANDOM-DISTRIBUTIONS::FB
;         (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC)))
;      0.0d0)
; 
; note: unable to open-code RATIONAL to FLOAT comparison due to type uncertainty: The first argument is a REAL, not a RATIONAL.

;     (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (ABS RANDOM-DISTRIBUTIONS::FC)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (ABS RANDOM-DISTRIBUTIONS::FB)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (>= (ABS RANDOM-DISTRIBUTIONS::FC) (ABS RANDOM-DISTRIBUTIONS::FB))
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (ABS RANDOM-DISTRIBUTIONS::B)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* 2.0 RANDOM-DISTRIBUTIONS::EPS (ABS RANDOM-DISTRIBUTIONS::B))
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL 0), not a (SIGNED-BYTE 64).

;     (* 0.5 RANDOM-DISTRIBUTIONS::TOL)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a T, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (+ (* 2.0 RANDOM-DISTRIBUTIONS::EPS (ABS RANDOM-DISTRIBUTIONS::B))
;        (* 0.5 RANDOM-DISTRIBUTIONS::TOL))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- RANDOM-DISTRIBUTIONS::C RANDOM-DISTRIBUTIONS::B)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (* 0.5 (- RANDOM-DISTRIBUTIONS::C RANDOM-DISTRIBUTIONS::B))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The result is a (VALUES (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).

;     (ABS RANDOM-DISTRIBUTIONS::XM)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a SINGLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (FLOAT 0.0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (<= (ABS RANDOM-DISTRIBUTIONS::XM) RANDOM-DISTRIBUTIONS::TOL1)
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (FLOAT 0.0), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (= RANDOM-DISTRIBUTIONS::FB 0.0d0)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).

;     (ABS RANDOM-DISTRIBUTIONS::E)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (< (ABS RANDOM-DISTRIBUTIONS::E) RANDOM-DISTRIBUTIONS::TOL1)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (ABS RANDOM-DISTRIBUTIONS::FA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (ABS RANDOM-DISTRIBUTIONS::FB)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (<= (ABS RANDOM-DISTRIBUTIONS::FA) (ABS RANDOM-DISTRIBUTIONS::FB))
; 
; note: forced to do full call
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.
;       The second argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (= RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::C)
; 
; note: forced to do GENERIC-= (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::S)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (- 1.0d0 RANDOM-DISTRIBUTIONS::S)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (/ RANDOM-DISTRIBUTIONS::FA RANDOM-DISTRIBUTIONS::FC)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FC)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::FB RANDOM-DISTRIBUTIONS::FA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::R 1.0d0)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;        (- RANDOM-DISTRIBUTIONS::R 1.0d0))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (-
;      (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;         (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
;      (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;         (- RANDOM-DISTRIBUTIONS::R 1.0d0)))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::S
;        (-
;         (* 2.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;            (- RANDOM-DISTRIBUTIONS::Q RANDOM-DISTRIBUTIONS::R))
;         (* (- RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::A)
;            (- RANDOM-DISTRIBUTIONS::R 1.0d0))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::Q 1.0d0)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- RANDOM-DISTRIBUTIONS::R 1.0d0)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0)
;        (- RANDOM-DISTRIBUTIONS::S 1.0d0))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::S 1.0d0)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* (- RANDOM-DISTRIBUTIONS::Q 1.0d0) (- RANDOM-DISTRIBUTIONS::R 1.0d0)
;        (- RANDOM-DISTRIBUTIONS::S 1.0d0))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::Q)
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR FLOAT (COMPLEX SINGLE-FLOAT) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;        (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (-
;      (* 3.0d0 RANDOM-DISTRIBUTIONS::XM RANDOM-DISTRIBUTIONS::Q
;         (ABS (* RANDOM-DISTRIBUTIONS::TOL1 RANDOM-DISTRIBUTIONS::Q))))
; 
; note: forced to do GENERIC-NEGATE (cost 10)
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (ABS (* 0.5d0 RANDOM-DISTRIBUTIONS::E RANDOM-DISTRIBUTIONS::Q))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (ABS RANDOM-DISTRIBUTIONS::D)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (> (ABS RANDOM-DISTRIBUTIONS::D) RANDOM-DISTRIBUTIONS::TOL1)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a (REAL 0), not a DOUBLE-FLOAT.

;     (+ RANDOM-DISTRIBUTIONS::B RANDOM-DISTRIBUTIONS::D)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.

;     (+ RANDOM-DISTRIBUTIONS::B
;        (RANDOM-DISTRIBUTIONS::TRANSFER-SIGN RANDOM-DISTRIBUTIONS::TOL1
;         RANDOM-DISTRIBUTIONS::XM))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (ABS RANDOM-DISTRIBUTIONS::FC)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 1) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (REAL 0) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC))
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 12) because:
;       The first argument is a NUMBER, not a (COMPLEX SINGLE-FLOAT).
;       The second argument is a (REAL 0), not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (COMPLEX SINGLE-FLOAT) &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::FB
;        (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a T, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a T, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (>
;      (* RANDOM-DISTRIBUTIONS::FB
;         (/ RANDOM-DISTRIBUTIONS::FC (ABS RANDOM-DISTRIBUTIONS::FC)))
;      0.0d0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.

;     (+ (* 2.0 RANDOM-DISTRIBUTIONS::EPS (ABS RANDOM-DISTRIBUTIONS::B))
;        (* 0.5 RANDOM-DISTRIBUTIONS::TOL))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-+

;     (+ RANDOM-DISTRIBUTIONS::B
;        (RANDOM-DISTRIBUTIONS::TRANSFER-SIGN RANDOM-DISTRIBUTIONS::TOL1
;         RANDOM-DISTRIBUTIONS::XM))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-+

;     (SETF RANDOM-DISTRIBUTIONS::P (ABS RANDOM-DISTRIBUTIONS::P))
; 
; note: doing float to pointer coercion (cost 13) to P

; in: DEFUN GIG-SETUP
;     (SQRT (/ RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (SQRT (* RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (SQRT
;      (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;         (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA)))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (/ RANDOM-DISTRIBUTIONS::YP)
; 
; note: unable to optimize due to type uncertainty: The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (EXP
;      (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;            (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &REST T).

;     (/ RANDOM-DISTRIBUTIONS::YM)
; 
; note: unable to optimize due to type uncertainty: The second argument is a NUMBER, not a INTEGER.The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES INTEGER &REST T).

;     (EXP
;      (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;            (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))))
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (LOG RANDOM-DISTRIBUTIONS::M)
; 
; note: unable to optimize due to type uncertainty: The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES FLOAT &REST T).

;     (* 2 RANDOM-DISTRIBUTIONS::X)
; 
; note: unable to optimize due to type uncertainty: The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (EXPT RANDOM-DISTRIBUTIONS::Y 3)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;        (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;           1.0d0))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline (unsigned-byte 64) arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The second argument is a NUMBER, not a (UNSIGNED-BYTE 64).
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES (UNSIGNED-BYTE 64) &OPTIONAL).
;       etc.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA 1.0d0)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;        (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;           1.0d0))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;        (-
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;               1.0d0)))
;        (* RANDOM-DISTRIBUTIONS::Y
;           (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA))
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::Y
;        (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;        (-
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;               1.0d0)))
;        (* RANDOM-DISTRIBUTIONS::Y
;           (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA (EXPT RANDOM-DISTRIBUTIONS::Y 3))
;        (-
;         (* RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::Y
;            (+ (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M) LAMBDA
;               1.0d0)))
;        (* RANDOM-DISTRIBUTIONS::Y
;           (- (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA)))
;        (* 0.5d0 RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::M))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;        (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ RANDOM-DISTRIBUTIONS::L1
;        (SQRT
;         (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;            (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (/
;      (+ RANDOM-DISTRIBUTIONS::L1
;         (SQRT
;          (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;             (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))))
;      RANDOM-DISTRIBUTIONS::BETA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* (- RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 19) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline fixnum arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a FIXNUM.
;       The second argument is a NUMBER, not a FIXNUM.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES FIXNUM &OPTIONAL).
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a SINGLE-FLOAT.
;       The second argument is a NUMBER, not a SINGLE-FLOAT.
;       The result is a (VALUES NUMBER &OPTIONAL), not a (VALUES SINGLE-FLOAT &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a NUMBER, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a NUMBER, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-- (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 4) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;           (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* (- RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;        (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;              (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
;        (EXP
;         (* -0.25d0 RANDOM-DISTRIBUTIONS::BETA
;            (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;               (- RANDOM-DISTRIBUTIONS::M) (- #)))))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR (COMPLEX DOUBLE-FLOAT) (DOUBLE-FLOAT 0.0d0)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       etc.

;     (* -0.25 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::M (/ RANDOM-DISTRIBUTIONS::M)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR (DOUBLE-FLOAT * 0.0d0) (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::M))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (+
;      (* -0.25 RANDOM-DISTRIBUTIONS::BETA
;         (+ RANDOM-DISTRIBUTIONS::M (/ RANDOM-DISTRIBUTIONS::M)))
;      (* 0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::M)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (SQRT (/ RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: doing float to pointer coercion (cost 13)

;     (SQRT (* RANDOM-DISTRIBUTIONS::PSI RANDOM-DISTRIBUTIONS::CHI))
; 
; note: doing float to pointer coercion (cost 13)

;     (- LAMBDA 1.0d0)
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first result of inline float arithmetic

;     (+ (* RANDOM-DISTRIBUTIONS::L1 RANDOM-DISTRIBUTIONS::L1)
;        (* RANDOM-DISTRIBUTIONS::BETA RANDOM-DISTRIBUTIONS::BETA))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-+

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YP RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: doing float to pointer coercion (cost 13)

;     (+ RANDOM-DISTRIBUTIONS::YP (/ RANDOM-DISTRIBUTIONS::YP)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC--

;     (EXPT (/ RANDOM-DISTRIBUTIONS::YM RANDOM-DISTRIBUTIONS::M)
;           (* 0.5d0 RANDOM-DISTRIBUTIONS::L1))
; 
; note: doing float to pointer coercion (cost 13)

;     (+ RANDOM-DISTRIBUTIONS::YM (/ RANDOM-DISTRIBUTIONS::YM)
;        (- RANDOM-DISTRIBUTIONS::M) (- (/ RANDOM-DISTRIBUTIONS::M)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC--

;     (* -0.25 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::M (/ RANDOM-DISTRIBUTIONS::M)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

;     (* 0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::M))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the first argument of GENERIC-*

; in: DEFUN %RANDOM-GIG
;     (* RANDOM-DISTRIBUTIONS::A
;        (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ RANDOM-DISTRIBUTIONS::M
;        (* RANDOM-DISTRIBUTIONS::A
;           (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
;        (* RANDOM-DISTRIBUTIONS::B
;           (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* RANDOM-DISTRIBUTIONS::B
;        (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ RANDOM-DISTRIBUTIONS::M
;        (* RANDOM-DISTRIBUTIONS::A
;           (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
;        (* RANDOM-DISTRIBUTIONS::B
;           (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1)))
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).

;     (+ (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
;        (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;           (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
;        RANDOM-DISTRIBUTIONS::C)
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

;     (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (* RANDOM-DISTRIBUTIONS::A
;        (/ RANDOM-DISTRIBUTIONS::R2 RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

;     (* RANDOM-DISTRIBUTIONS::B
;        (/ (- 1.0d0 RANDOM-DISTRIBUTIONS::R2) RANDOM-DISTRIBUTIONS::R1))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

;     (* -0.5d0 RANDOM-DISTRIBUTIONS::L1 (LOG RANDOM-DISTRIBUTIONS::Y))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

;     (* 0.25d0 RANDOM-DISTRIBUTIONS::BETA
;        (+ RANDOM-DISTRIBUTIONS::Y (/ RANDOM-DISTRIBUTIONS::Y)))
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; in: DEFUN RANDOM-GIG
;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (COERCE LAMBDA 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::CHI 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL 0), not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::PSI 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL 0), not a (SIGNED-BYTE 64).

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* SETF SETQ THE + 
; ==>
;   1
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + 
; ==>
;   1
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

; --> BLOCK LET 
; ==>
;   (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (RANDOM-DISTRIBUTIONS::GIG-SETUP LAMBDA RANDOM-DISTRIBUTIONS::CHI
;      RANDOM-DISTRIBUTIONS::PSI)
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* SETF SETQ THE + 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; in: DEFUN MAKE-RANDOM-VARIABLE-GIG
;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* SETF SETQ THE + 
; ==>
;   1
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + 
; ==>
;   1
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-* (cost 30)
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 5) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.
; 
; note: forced to do GENERIC-+ (cost 10)
;       unable to do inline float arithmetic (cost 2) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a DOUBLE-FLOAT.
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).
;       unable to do inline float arithmetic (cost 3) because:
;       The first argument is a (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)), not a (COMPLEX DOUBLE-FLOAT).
;       The second argument is a T, not a (COMPLEX DOUBLE-FLOAT).
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES (COMPLEX DOUBLE-FLOAT) &OPTIONAL).
;       etc.

; --> BLOCK LET 
; ==>
;   (/ RANDOM-DISTRIBUTIONS::Y RANDOM-DISTRIBUTIONS::ALPHA)
; 
; note: forced to do full call
;       unable to do inline float arithmetic (cost 19) because:
;       The second argument is a T, not a DOUBLE-FLOAT.
;       The result is a (VALUES (OR DOUBLE-FLOAT (COMPLEX DOUBLE-FLOAT)) &OPTIONAL), not a (VALUES DOUBLE-FLOAT &OPTIONAL).

;     (< RANDOM-DISTRIBUTIONS::CHI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (< RANDOM-DISTRIBUTIONS::PSI 0)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (COERCE LAMBDA 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a T, not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a T, not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::CHI 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL 0), not a (SIGNED-BYTE 64).

;     (COERCE RANDOM-DISTRIBUTIONS::PSI 'DOUBLE-FLOAT)
; 
; note: forced to do full call
;       unable to do inline float coercion (cost 2) because:
;       The first argument is a (REAL 0), not a SINGLE-FLOAT.
;       unable to do inline float coercion (cost 5) because:
;       The first argument is a (REAL 0), not a (SIGNED-BYTE 64).

;     (RANDOM-DISTRIBUTIONS::GIG-SETUP LAMBDA RANDOM-DISTRIBUTIONS::CHI
;      RANDOM-DISTRIBUTIONS::PSI)
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing float to pointer coercion (cost 13)
; 
; note: doing float to pointer coercion (cost 13)

;     (RANDOM-DISTRIBUTIONS::%RANDOM-GIG RANDOM-DISTRIBUTIONS::L1
;      RANDOM-DISTRIBUTIONS::ALPHA RANDOM-DISTRIBUTIONS::BETA
;      RANDOM-DISTRIBUTIONS::M RANDOM-DISTRIBUTIONS::A RANDOM-DISTRIBUTIONS::B
;      RANDOM-DISTRIBUTIONS::C)
; --> BLOCK LET TAGBODY LET* SETF SETQ THE + 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; --> BLOCK LET TAGBODY LET* WHEN IF AND IF >= + 
; ==>
;   1
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*
; 
; note: doing float to pointer coercion (cost 13), for:
;       the second argument of GENERIC-*

; in: DEFUN TEST-GIG-RANGE
;     (> RANDOM-DISTRIBUTIONS::X 0)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO 100000
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::X = (FUNCALL
;                                                                RANDOM-DISTRIBUTIONS::R)
;           RANDOM-DISTRIBUTIONS::COUNTING ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF 
; ==>
;   (< #:MINMAXTMP0 MIN)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

; ==>
;   (> #:MINMAXTMP2 MAX)
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a SINGLE-FLOAT.The second argument is a REAL, not a RATIONAL.
; 
; note: unable to open-code FLOAT to RATIONAL comparison due to type uncertainty: The first argument is a REAL, not a DOUBLE-FLOAT.The second argument is a REAL, not a RATIONAL.

;     (> RANDOM-DISTRIBUTIONS::X 0)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a T, not a FIXNUM.
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a T, not a FIXNUM.
;       etc.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO 100000
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::X = (FUNCALL
;                                                                RANDOM-DISTRIBUTIONS::R)
;           RANDOM-DISTRIBUTIONS::COUNTING ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF 
; ==>
;   (< #:MINMAXTMP0 MIN)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; ==>
;   (> #:MINMAXTMP2 MAX)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a SINGLE-FLOAT.
;       The second argument is a REAL, not a SINGLE-FLOAT.
;       unable to do inline float comparison (cost 3) because:
;       The first argument is a REAL, not a DOUBLE-FLOAT.
;       The second argument is a REAL, not a DOUBLE-FLOAT.
;       etc.

; in: DEFUN TEST-GIG-SPEED
;     (> RANDOM-DISTRIBUTIONS::X 0)
; 
; note: forced to do >-INTEGER-FIXNUM (cost 8)
;       unable to do inline fixnum comparison (cost 3) because:
;       The first argument is a INTEGER, not a FIXNUM.

;     (LOOP RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::I RANDOM-DISTRIBUTIONS::FROM 0 RANDOM-DISTRIBUTIONS::TO 100000
;           RANDOM-DISTRIBUTIONS::FOR RANDOM-DISTRIBUTIONS::X = (RANDOM-DISTRIBUTIONS:RANDOM-POISSON
;                                                                (RANDOM-DISTRIBUTIONS:RANDOM-GIG
;                                                                 -0.7277 0.0417
;                                                                 0.0016))
;           RANDOM-DISTRIBUTIONS::COUNTING ...)
; --> LET LET SB-LOOP::WITH-SUM-COUNT LET SB-LOOP::WITH-MINIMAX-VALUE LET 
; --> SB-LOOP::WITH-MINIMAX-VALUE LET TAGBODY 
; --> SB-LOOP::LOOP-ACCUMULATE-MINIMAX-VALUE PROGN WHEN IF OR LET IF 
; ==>
;   (< #:MINMAXTMP0 MIN)
; 
; note: forced to do GENERIC-< (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

; ==>
;   (> #:MINMAXTMP2 MAX)
; 
; note: forced to do GENERIC-> (cost 10)
;       unable to do inline fixnum comparison (cost 4) because:
;       The first argument is a INTEGER, not a FIXNUM.
;       The second argument is a INTEGER, not a FIXNUM.

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/specialized-function/38013b2d082293c187d03aeca9a5ed5200773702/specialized-function-20250831-git/src/1common.lisp
; in: DEFUN UPGRADED-OBJECT-TYPE
;     (SINGLE-FLOAT 'SINGLE-FLOAT)
; 
; caught STYLE-WARNING:
;   Clause SINGLE-FLOAT is shadowed by SHORT-FLOAT

;     ((COMPLEX BIGNUM) '(COMPLEX BIGNUM))
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX BIGNUM) is shadowed by (COMPLEX FIXNUM)

;     ((COMPLEX RATIO) '(COMPLEX RATIO))
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX RATIO) is shadowed by (COMPLEX FIXNUM)

;     ((COMPLEX SINGLE-FLOAT) '(COMPLEX SINGLE-FLOAT))
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX SINGLE-FLOAT) is shadowed by (COMPLEX SHORT-FLOAT)

;     ((COMPLEX LONG-FLOAT) '(COMPLEX LONG-FLOAT))
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX LONG-FLOAT) is shadowed by (COMPLEX DOUBLE-FLOAT)

;     (ETYPECASE SPECIALIZED-FUNCTION::X
;       (FIXNUM 'FIXNUM)
;       ((UNSIGNED-BYTE 64) '(UNSIGNED-BYTE 64))
;       ((SIGNED-BYTE 64) '(SIGNED-BYTE 64))
;       (BIGNUM 'BIGNUM)
;       (RATIO 'RATIO)
;       (SHORT-FLOAT 'SHORT-FLOAT)
;       (SINGLE-FLOAT 'SINGLE-FLOAT)
;       (DOUBLE-FLOAT 'DOUBLE-FLOAT)
;       (LONG-FLOAT 'LONG-FLOAT)
;       ((COMPLEX FIXNUM) '(COMPLEX FIXNUM))
;       ...)
; --> IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF IF 
; --> TYPEP 
; ==>
;   1
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; in: DEFUN SPECIALIZED-FUNCTION-FORM
;     (SPECIALIZED-FUNCTION::UPGRADED-OBJECT-TYPE SPECIALIZED-FUNCTION::VAL)
; 
; caught STYLE-WARNING:
;   Clause SINGLE-FLOAT is shadowed by SHORT-FLOAT
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX BIGNUM) is shadowed by (COMPLEX FIXNUM)
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX RATIO) is shadowed by (COMPLEX FIXNUM)
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX SINGLE-FLOAT) is shadowed by (COMPLEX SHORT-FLOAT)
; 
; caught STYLE-WARNING:
;   Clause (COMPLEX LONG-FLOAT) is shadowed by (COMPLEX DOUBLE-FLOAT)
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "specialized-function" "1common">

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/4ca347e38e7a13acb9e28299d948cbbb14aea799/numcl-20250831-git/src/1constants.lisp
; in: DEFUN ZERO-VALUE
;     (CASE NUMCL.IMPL::+NUMCL-DEFAULT-FLOAT-FORMAT+
;       (SHORT-FLOAT 0.0)
;       (SINGLE-FLOAT 0.0)
;       (DOUBLE-FLOAT 0.0d0)
;       (LONG-FLOAT 0.0d0))
; --> COND IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   0.0d0
; 
; note: deleting unreachable code

; in: DEFUN ONE-VALUE
;     (CASE NUMCL.IMPL::+NUMCL-DEFAULT-FLOAT-FORMAT+
;       (SHORT-FLOAT 1.0)
;       (SINGLE-FLOAT 1.0)
;       (DOUBLE-FLOAT 1.0d0)
;       (LONG-FLOAT 1.0d0))
; --> COND IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   1.0d0
; 
; note: deleting unreachable code

; in: DEFUN MOST-POSITIVE-VALUE
;     (CASE NUMCL.IMPL::+NUMCL-DEFAULT-FLOAT-FORMAT+
;       (SHORT-FLOAT MOST-POSITIVE-SHORT-FLOAT)
;       (SINGLE-FLOAT MOST-POSITIVE-SINGLE-FLOAT)
;       (DOUBLE-FLOAT MOST-POSITIVE-DOUBLE-FLOAT)
;       (LONG-FLOAT MOST-POSITIVE-LONG-FLOAT))
; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-POSITIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-POSITIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-POSITIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF 
; ==>
;   MOST-POSITIVE-SINGLE-FLOAT
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; in: DEFUN MOST-NEGATIVE-VALUE
;     (CASE NUMCL.IMPL::+NUMCL-DEFAULT-FLOAT-FORMAT+
;       (SHORT-FLOAT MOST-NEGATIVE-SHORT-FLOAT)
;       (SINGLE-FLOAT MOST-NEGATIVE-SINGLE-FLOAT)
;       (DOUBLE-FLOAT MOST-NEGATIVE-DOUBLE-FLOAT)
;       (LONG-FLOAT MOST-NEGATIVE-LONG-FLOAT))
; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF 
; ==>
;   MOST-NEGATIVE-SHORT-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF 
; ==>
;   MOST-NEGATIVE-DOUBLE-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF IF IF 
; ==>
;   MOST-NEGATIVE-LONG-FLOAT
; 
; note: deleting unreachable code

; --> COND IF IF 
; ==>
;   MOST-NEGATIVE-SINGLE-FLOAT
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/4ca347e38e7a13acb9e28299d948cbbb14aea799/numcl-20250831-git/src/1type.lisp
; in: DEFUN FLOAT-SUBSTITUTION
;     (ERROR "this should not happen")
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/4ca347e38e7a13acb9e28299d948cbbb14aea799/numcl-20250831-git/src/2aref.lisp
; in: DEFUN %AREF
;     (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::SUBSCRIPTS
;       (NIL ARRAY)
;       ((LIST*
;         (NUMCL.IMPL::SUB NUMCL.IMPL::START NUMCL.IMPL::STOP STEP
;                          NUMCL.IMPL::WIDTH NUMCL.EXPORTED:FULL
;                          NUMCL.IMPL::CONTIGUOUS)
;         REST)
;        (COND ((= 1 NUMCL.IMPL::WIDTH) (NUMCL.IMPL::%AREF # REST))
;              ((AND NUMCL.EXPORTED:FULL #) ARRAY)
;              ((AND NUMCL.IMPL::CONTIGUOUS #)
;               (NUMCL.IMPL::%DISPLACE-RANGE ARRAY NUMCL.IMPL::START
;                NUMCL.IMPL::STOP))
;              (T (OR # #)))))
; --> TRIVIA.LEVEL2:MATCH2+ 
; ==>
;   (TRIVIA.LEVEL2:MATCH2*+ (NUMCL.IMPL::SUBSCRIPTS)
;       (T)
;     ((NIL) ARRAY)
;     (((LIST*
;        (NUMCL.IMPL::SUB NUMCL.IMPL::START NUMCL.IMPL::STOP STEP
;                         NUMCL.IMPL::WIDTH NUMCL.EXPORTED:FULL
;                         NUMCL.IMPL::CONTIGUOUS)
;        REST))
;      (COND ((= 1 NUMCL.IMPL::WIDTH) (NUMCL.IMPL::%AREF # REST))
;            ((AND NUMCL.EXPORTED:FULL #) ARRAY)
;            ((AND NUMCL.IMPL::CONTIGUOUS #)
;             (NUMCL.IMPL::%DISPLACE-RANGE ARRAY NUMCL.IMPL::START
;              NUMCL.IMPL::STOP))
;            (T (OR # #))))
;     ((#:OTHERWISE0)
;      (ERROR 'TRIVIA.LEVEL2:MATCH-ERROR :PATTERN '((NIL ARRAY) (# #)) :VALUES
;             (LIST #:OTHERWISE0))))
; 
; caught STYLE-WARNING:
;   Calling #<FUNCTION SUB-START> failed, but not by program-error (TYPE-ERROR).
;   Trivia probed candidate function #<FUNCTION SUB-START> by calling it with 
;   a single dummy argument 42. The call may fail due to various reasons,
;   but program-error is a strong indication of not being unary.
;    In order to disable this probing, run (SETF *ARITY-CHECK-BY-TEST-CALL* NIL) .
;   
;   Note: This style warning is shown only once.
WARNING: Lisp compilation had style-warnings while compiling #<CL-SOURCE-FILE "numcl" "src" "2aref">
WARNING: Duplicate definition for 1+-INFERER found in one file.
See also:
  The ANSI Standard, Section 3.2.2.3

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/4ca347e38e7a13acb9e28299d948cbbb14aea799/numcl-20250831-git/src/3arange.lisp
; in: DEFUN %ARANGE-INFER-TYPE
;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MINIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MAXIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MINIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MAXIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/4ca347e38e7a13acb9e28299d948cbbb14aea799/numcl-20250831-git/src/3arange.lisp
; in: DEFINE-COMPILER-MACRO ARANGE
;     (DEFINE-COMPILER-MACRO NUMCL.EXPORTED:ARANGE
;         (&REST NUMCL.IMPL::ARGS &ENVIRONMENT NUMCL.IMPL::ENV)
;       (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;         ((LIST NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP ,TYPE))
;         ((LIST NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP
;                ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))))
; --> EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO 
; ==>
;   (SB-INT:NAMED-LAMBDA (COMPILER-MACRO NUMCL.EXPORTED:ARANGE)
;       (#:EXPR NUMCL.IMPL::ENV)
;     (DECLARE (SB-C::LAMBDA-LIST (&REST NUMCL.IMPL::ARGS)))
;     (SB-INT:NAMED-DS-BIND (:MACRO NUMCL.EXPORTED:ARANGE . DEFINE-COMPILER-MACRO)
;         (&REST NUMCL.IMPL::ARGS)
;         (SB-C::COMPILER-MACRO-ARGS #:EXPR)
;       (DECLARE (SB-C::CONSTANT-VALUE NUMCL.IMPL::ARGS)
;                (SB-C::NO-COMPILER-MACRO NUMCL.EXPORTED:ARANGE))
;       (BLOCK NUMCL.EXPORTED:ARANGE
;         (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;           (# `#)
;           (# `#)
;           (# `#)
;           (# #)
;           (# #)
;           (# #)))))
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier

; in: DEFINE-COMPILER-MACRO ARANGE
;     (DEFINE-COMPILER-MACRO NUMCL.EXPORTED:ARANGE
;         (&REST NUMCL.IMPL::ARGS &ENVIRONMENT NUMCL.IMPL::ENV)
;       (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;         ((LIST NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP ,TYPE))
;         ((LIST NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP
;                ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%DEFINE-COMPILER-MACRO 'NUMCL.EXPORTED:ARANGE
;                                 (SB-INT:NAMED-LAMBDA (COMPILER-MACRO
;                                                       NUMCL.EXPORTED:ARANGE)
;                                     (#:EXPR NUMCL.IMPL::ENV)
;                                   (DECLARE
;                                    (SB-C::LAMBDA-LIST (&REST NUMCL.IMPL::ARGS)))
;                                   (SB-INT:NAMED-DS-BIND (:MACRO
;                                                          NUMCL.EXPORTED:ARANGE
;                                                          . DEFINE-COMPILER-MACRO)
;                                       (&REST NUMCL.IMPL::ARGS)
;                                       (SB-C::COMPILER-MACRO-ARGS #:EXPR)
;                                     (DECLARE
;                                      (SB-C::CONSTANT-VALUE NUMCL.IMPL::ARGS)
;                                      (SB-C::NO-COMPILER-MACRO
;                                       NUMCL.EXPORTED:ARANGE))
;                                     (BLOCK NUMCL.EXPORTED:ARANGE
;                                       (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;                                         #
;                                         #
;                                         #
;                                         #
;                                         #
;                                         #)))))
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD tid=899974 "main thread" RUNNING {123FAC0003}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "numcl" "src" "3arange">

Backtrace for: #<SB-THREAD:THREAD tid=899974 "main thread" RUNNING {123FAC0003}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {120A63F563}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {120A63F563}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {120A63F563}>)
3: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">)))
4: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">)
6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
7: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12046733F3}>) [fast-method]
9: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
10: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12046733F3}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
12: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "numcl")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {120466C82B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {120462B80B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "numcl" "numcl")
23: (DEPCHECK::MAGIC "numcl" "numcl" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-oNDx338f/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "numcl" "numcl" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-oNDx338f/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-oNDx338f/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
28: (SB-IMPL::%START-LISP)

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

numcl.test

WARNING: Duplicate definition for 1+-INFERER found in one file.
See also:
  The ANSI Standard, Section 3.2.2.3

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/4ca347e38e7a13acb9e28299d948cbbb14aea799/numcl-20250831-git/src/3arange.lisp
; in: DEFUN %ARANGE-INFER-TYPE
;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MINIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MAXIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MINIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

;     (NUMCL.IMPL::%COERCE NUMCL.IMPL::MAXIMUM NUMCL.IMPL::TYPESPEC)
; 
; note: deleting unreachable code

; file: /home/quicklisp/quicklisp-controller/dist/build-cache/numcl/4ca347e38e7a13acb9e28299d948cbbb14aea799/numcl-20250831-git/src/3arange.lisp
; in: DEFINE-COMPILER-MACRO ARANGE
;     (DEFINE-COMPILER-MACRO NUMCL.EXPORTED:ARANGE
;         (&REST NUMCL.IMPL::ARGS &ENVIRONMENT NUMCL.IMPL::ENV)
;       (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;         ((LIST NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP ,TYPE))
;         ((LIST NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP
;                ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))))
; --> EVAL-WHEN SB-C::%DEFINE-COMPILER-MACRO 
; ==>
;   (SB-INT:NAMED-LAMBDA (COMPILER-MACRO NUMCL.EXPORTED:ARANGE)
;       (#:EXPR NUMCL.IMPL::ENV)
;     (DECLARE (SB-C::LAMBDA-LIST (&REST NUMCL.IMPL::ARGS)))
;     (SB-INT:NAMED-DS-BIND (:MACRO NUMCL.EXPORTED:ARANGE . DEFINE-COMPILER-MACRO)
;         (&REST NUMCL.IMPL::ARGS)
;         (SB-C::COMPILER-MACRO-ARGS #:EXPR)
;       (DECLARE (SB-C::CONSTANT-VALUE NUMCL.IMPL::ARGS)
;                (SB-C::NO-COMPILER-MACRO NUMCL.EXPORTED:ARANGE))
;       (BLOCK NUMCL.EXPORTED:ARANGE
;         (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;           (# `#)
;           (# `#)
;           (# `#)
;           (# #)
;           (# #)
;           (# #)))))
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier

; in: DEFINE-COMPILER-MACRO ARANGE
;     (DEFINE-COMPILER-MACRO NUMCL.EXPORTED:ARANGE
;         (&REST NUMCL.IMPL::ARGS &ENVIRONMENT NUMCL.IMPL::ENV)
;       (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;         ((LIST NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ,TYPE))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP :TYPE TYPE)
;          `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP ,TYPE))
;         ((LIST NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE 0 ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP 1 ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))
;         ((LIST NUMCL.IMPL::START NUMCL.IMPL::STOP STEP)
;          (IF (EVERY # NUMCL.IMPL::ARGS)
;              `(NUMCL.IMPL::%%ARANGE ,NUMCL.IMPL::START ,NUMCL.IMPL::STOP ,STEP
;                ',#)
;              (ALEXANDRIA:ONCE-ONLY #
;                `#)))))
; --> EVAL-WHEN 
; ==>
;   (SB-C::%DEFINE-COMPILER-MACRO 'NUMCL.EXPORTED:ARANGE
;                                 (SB-INT:NAMED-LAMBDA (COMPILER-MACRO
;                                                       NUMCL.EXPORTED:ARANGE)
;                                     (#:EXPR NUMCL.IMPL::ENV)
;                                   (DECLARE
;                                    (SB-C::LAMBDA-LIST (&REST NUMCL.IMPL::ARGS)))
;                                   (SB-INT:NAMED-DS-BIND (:MACRO
;                                                          NUMCL.EXPORTED:ARANGE
;                                                          . DEFINE-COMPILER-MACRO)
;                                       (&REST NUMCL.IMPL::ARGS)
;                                       (SB-C::COMPILER-MACRO-ARGS #:EXPR)
;                                     (DECLARE
;                                      (SB-C::CONSTANT-VALUE NUMCL.IMPL::ARGS)
;                                      (SB-C::NO-COMPILER-MACRO
;                                       NUMCL.EXPORTED:ARANGE))
;                                     (BLOCK NUMCL.EXPORTED:ARANGE
;                                       (TRIVIA.LEVEL2:EMATCH NUMCL.IMPL::ARGS
;                                         #
;                                         #
;                                         #
;                                         #
;                                         #
;                                         #)))))
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
; 
; caught WARNING:
;   * is not permitted as a type specifier
Unhandled UIOP/LISP-BUILD:COMPILE-FILE-ERROR in thread #<SB-THREAD:THREAD tid=899979 "main thread" RUNNING {123FC380A3}>: COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "numcl" "src" "3arange">

Backtrace for: #<SB-THREAD:THREAD tid=899979 "main thread" RUNNING {123FC380A3}>
0: (SB-DEBUG::DEBUGGER-DISABLED-HOOK #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {12327B7623}> #<unused argument> :QUIT T)
1: (SB-DEBUG::RUN-HOOK *INVOKE-DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {12327B7623}>)
2: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {12327B7623}>)
3: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">)))
4: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">)))
5: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">)
6: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
7: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "numcl" "src" "3arange">) [fast-method]
8: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12046EEF03}>) [fast-method]
9: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
10: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {12046EEF03}>) [fast-method]
11: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
12: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test">)
13: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
14: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "numcl.test">) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP "numcl.test")
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl.test") [fast-method]
18: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {120470318B}> :OVERRIDE T :KEY NIL :OVERRIDE-CACHE T :OVERRIDE-FORCING NIL)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {12046C218B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP "numcl.test") [fast-method]
22: (DEPCHECK::COMPUTE-DEPENDENCIES "numcl.test" "numcl.test")
23: (DEPCHECK::MAGIC "numcl.test" "numcl.test" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-eqJQjr5g/depcheck-win.txt")
24: (DEPCHECK::MAIN ("depcheck" "/home/quicklisp/quicklisp-controller/dist/system-file-index" "numcl.test" "numcl.test" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-eqJQjr5g/depcheck-win.txt" "/home/quicklisp/quicklisp-controller/tmp/anonymous/anonymous-eqJQjr5g/depcheck-fail.txt"))
25: ((LAMBDA NIL :IN "/home/quicklisp/quicklisp/local-projects/quicklisp-controller/dumper-2SKVI5f7.lisp"))
26: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
27: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
28: (SB-IMPL::%START-LISP)

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